Coverage Report - com.googlecode.sparkleg.SparqlParser
 
Classes in this File Line Coverage Branch Coverage Complexity
SparqlParser
84%
7948/9351
24%
1203/4886
11,608
SparqlParser$DFA4
91%
11/12
N/A
11,608
SparqlParser$add_return
0%
0/2
N/A
11,608
SparqlParser$additiveExpression_return
100%
2/2
N/A
11,608
SparqlParser$additiveOperator_return
100%
2/2
N/A
11,608
SparqlParser$aggregate_return
100%
2/2
N/A
11,608
SparqlParser$anon_return
100%
2/2
N/A
11,608
SparqlParser$argList_return
100%
2/2
N/A
11,608
SparqlParser$askQuery_return
100%
2/2
N/A
11,608
SparqlParser$baseDecl_return
100%
2/2
N/A
11,608
SparqlParser$bind_return
100%
2/2
N/A
11,608
SparqlParser$bindingValueList_return
100%
2/2
N/A
11,608
SparqlParser$bindingValue_return
100%
2/2
N/A
11,608
SparqlParser$bindingsClause_return
100%
2/2
N/A
11,608
SparqlParser$blankNode_return
100%
2/2
N/A
11,608
SparqlParser$booleanLiteral_return
100%
2/2
N/A
11,608
SparqlParser$brackettedExpression_return
100%
2/2
N/A
11,608
SparqlParser$builtInCall_return
100%
2/2
N/A
11,608
SparqlParser$clear_return
100%
2/2
N/A
11,608
SparqlParser$conditionalAndExpression_return
100%
2/2
N/A
11,608
SparqlParser$conditionalOrExpression_return
100%
2/2
N/A
11,608
SparqlParser$constraint_return
100%
2/2
N/A
11,608
SparqlParser$constructQuery_return
100%
2/2
N/A
11,608
SparqlParser$constructTemplate_return
100%
2/2
N/A
11,608
SparqlParser$constructTriples_return
100%
2/2
N/A
11,608
SparqlParser$copy_return
0%
0/2
N/A
11,608
SparqlParser$create_return
0%
0/2
N/A
11,608
SparqlParser$datasetClause_return
100%
2/2
N/A
11,608
SparqlParser$deleteClause_return
100%
2/2
N/A
11,608
SparqlParser$deleteData_return
100%
2/2
N/A
11,608
SparqlParser$deleteWhere_return
100%
2/2
N/A
11,608
SparqlParser$delete_return
100%
2/2
N/A
11,608
SparqlParser$describeQuery_return
100%
2/2
N/A
11,608
SparqlParser$drop_return
100%
2/2
N/A
11,608
SparqlParser$existsFunction_return
100%
2/2
N/A
11,608
SparqlParser$expressionList_return
100%
2/2
N/A
11,608
SparqlParser$expression_return
100%
2/2
N/A
11,608
SparqlParser$filter_return
100%
2/2
N/A
11,608
SparqlParser$functionCall_return
100%
2/2
N/A
11,608
SparqlParser$graphGraphPattern_return
100%
2/2
N/A
11,608
SparqlParser$graphNode_return
100%
2/2
N/A
11,608
SparqlParser$graphOrDefault_return
0%
0/2
N/A
11,608
SparqlParser$graphPatternNotTriples_return
100%
2/2
N/A
11,608
SparqlParser$graphRefAll_return
100%
2/2
N/A
11,608
SparqlParser$graphRef_return
100%
2/2
N/A
11,608
SparqlParser$graphTerm_return
100%
2/2
N/A
11,608
SparqlParser$groupClause_return
100%
2/2
N/A
11,608
SparqlParser$groupCondition_return
100%
2/2
N/A
11,608
SparqlParser$groupGraphPatternSubDetail_return
100%
2/2
N/A
11,608
SparqlParser$groupGraphPatternSub_return
100%
2/2
N/A
11,608
SparqlParser$groupGraphPattern_return
100%
2/2
N/A
11,608
SparqlParser$groupOrUnionGraphPattern_return
100%
2/2
N/A
11,608
SparqlParser$havingClause_return
100%
2/2
N/A
11,608
SparqlParser$insertClause_return
100%
2/2
N/A
11,608
SparqlParser$insert_return
100%
2/2
N/A
11,608
SparqlParser$iriRefOrFunction_return
100%
2/2
N/A
11,608
SparqlParser$iriRef_return
100%
2/2
N/A
11,608
SparqlParser$limitClause_return
100%
2/2
N/A
11,608
SparqlParser$limitOffsetClauses_return
100%
2/2
N/A
11,608
SparqlParser$load_return
0%
0/2
N/A
11,608
SparqlParser$minusGraphPattern_return
100%
2/2
N/A
11,608
SparqlParser$modify_return
100%
2/2
N/A
11,608
SparqlParser$move_return
0%
0/2
N/A
11,608
SparqlParser$multiplicativeExpression_return
100%
2/2
N/A
11,608
SparqlParser$multiplicativeOperator_return
100%
2/2
N/A
11,608
SparqlParser$nil_return
100%
2/2
N/A
11,608
SparqlParser$notExistsFunction_return
100%
2/2
N/A
11,608
SparqlParser$numericExpression_return
100%
2/2
N/A
11,608
SparqlParser$numericLiteralNegative_return
100%
2/2
N/A
11,608
SparqlParser$numericLiteralPositive_return
100%
2/2
N/A
11,608
SparqlParser$numericLiteralUnsigned_return
100%
2/2
N/A
11,608
SparqlParser$numericLiteral_return
100%
2/2
N/A
11,608
SparqlParser$objectList_return
100%
2/2
N/A
11,608
SparqlParser$offsetClause_return
100%
2/2
N/A
11,608
SparqlParser$optionalGraphPattern_return
100%
2/2
N/A
11,608
SparqlParser$orderClause_return
100%
2/2
N/A
11,608
SparqlParser$orderCondition_return
100%
2/2
N/A
11,608
SparqlParser$pathEltOrInverse_return
100%
2/2
N/A
11,608
SparqlParser$pathElt_return
100%
2/2
N/A
11,608
SparqlParser$pathMod_return
100%
2/2
N/A
11,608
SparqlParser$pathNegatedPropertySet_return
100%
2/2
N/A
11,608
SparqlParser$pathOneInPropertySet_return
100%
2/2
N/A
11,608
SparqlParser$pathPrimary_return
100%
2/2
N/A
11,608
SparqlParser$pathSequence_return
100%
2/2
N/A
11,608
SparqlParser$path_return
100%
2/2
N/A
11,608
SparqlParser$prefixDecl_return
100%
2/2
N/A
11,608
SparqlParser$prefixedName_return
100%
2/2
N/A
11,608
SparqlParser$primaryExpression_return
100%
2/2
N/A
11,608
SparqlParser$prologue_return
100%
2/2
N/A
11,608
SparqlParser$propertyListNotEmptyDetails_return
100%
2/2
N/A
11,608
SparqlParser$propertyListNotEmptyPath_return
100%
2/2
N/A
11,608
SparqlParser$propertyListNotEmpty_return
100%
2/2
N/A
11,608
SparqlParser$quadPattern_return
100%
2/2
N/A
11,608
SparqlParser$quadsDetails_return
100%
2/2
N/A
11,608
SparqlParser$quadsNotTriples_return
100%
2/2
N/A
11,608
SparqlParser$quads_return
100%
2/2
N/A
11,608
SparqlParser$query_return
100%
2/2
N/A
11,608
SparqlParser$rdfLiteral_return
100%
2/2
N/A
11,608
SparqlParser$regexExpression_return
100%
2/2
N/A
11,608
SparqlParser$relationalExpression_return
100%
2/2
N/A
11,608
SparqlParser$selectClause_return
100%
2/2
N/A
11,608
SparqlParser$selectQuery_return
100%
2/2
N/A
11,608
SparqlParser$selectVariables_return
100%
2/2
N/A
11,608
SparqlParser$serviceGraphPattern_return
100%
2/2
N/A
11,608
SparqlParser$solutionModifier_return
100%
2/2
N/A
11,608
SparqlParser$string_return
100%
2/2
N/A
11,608
SparqlParser$subSelect_return
100%
2/2
N/A
11,608
SparqlParser$subStringExpression_return
100%
2/2
N/A
11,608
SparqlParser$triplesBlock_return
100%
2/2
N/A
11,608
SparqlParser$triplesNode_return
100%
2/2
N/A
11,608
SparqlParser$triplesSameSubjectPath_return
100%
2/2
N/A
11,608
SparqlParser$triplesSameSubject_return
100%
2/2
N/A
11,608
SparqlParser$triplesTemplate_return
100%
2/2
N/A
11,608
SparqlParser$unaryExpression_return
100%
2/2
N/A
11,608
SparqlParser$update_return
100%
2/2
N/A
11,608
SparqlParser$usingClause_return
100%
2/2
N/A
11,608
SparqlParser$valueLogical_return
100%
2/2
N/A
11,608
SparqlParser$varOrIRIref_return
100%
2/2
N/A
11,608
SparqlParser$varOrTerm_return
100%
2/2
N/A
11,608
SparqlParser$var_return
100%
2/2
N/A
11,608
SparqlParser$verbPath_return
100%
2/2
N/A
11,608
SparqlParser$verbSimpleOrPath_return
100%
2/2
N/A
11,608
SparqlParser$verbSimple_return
100%
2/2
N/A
11,608
SparqlParser$verb_return
0%
0/2
N/A
11,608
SparqlParser$whereClause_return
100%
2/2
N/A
11,608
 
 1  
 // $ANTLR 3.4 com\\googlecode\\sparkleg\\Sparql.g 2011-12-25 17:43:15
 2  
 
 3  
     package com.googlecode.sparkleg;
 4  
 
 5  
 
 6  
 import org.antlr.runtime.*;
 7  
 import java.util.Stack;
 8  
 import java.util.List;
 9  
 import java.util.ArrayList;
 10  
 
 11  
 import org.antlr.runtime.tree.*;
 12  
 
 13  
 
 14  
 /**
 15  
  * @author Simone Tripodi   (simone.tripodi)
 16  
  * @author Michele Mostarda (michele.mostarda)
 17  
  * @author Juergen Pfundt   (Juergen.Pfundt)
 18  
  * @version $Id: Sparql.g 226 2011-10-22 21:13:52Z Juergen.Pfundt@gmail.com $
 19  
  */
 20  
 @SuppressWarnings({"all", "warnings", "unchecked"})
 21  
 public class SparqlParser extends Parser {
 22  1
     public static final String[] tokenNames = new String[] {
 23  
         "<invalid>", "<EOR>", "<DOWN>", "<UP>", "A", "ABS", "ADD", "ALL", "AND", "ANY", "ARG_LIST", "AS", "ASC", "ASK", "ASTERISK", "AVG", "BASE", "BIND", "BINDINGS", "BINDING_VALUE", "BLANK_NODE", "BLANK_NODE_LABEL", "BNODE", "BOUND", "BRACKETTED_EXPRESSION", "BY", "CEIL", "CLEAR", "CLOSE_BRACE", "CLOSE_CURLY_BRACE", "CLOSE_SQUARE_BRACKET", "COALESCE", "COLLECTION", "COMMA", "COMMENT", "CONCAT", "CONSTRUCT", "CONSTRUCT_TRIPLES", "CONTAINS", "COPY", "COUNT", "CREATE", "DATA", "DATATYPE", "DAY", "DECIMAL", "DECIMAL_NEGATIVE", "DECIMAL_POSITIVE", "DEFAULT", "DELETE", "DESC", "DESCRIBE", "DIGIT", "DISTINCT", "DIVIDE", "DOT", "DOUBLE", "DOUBLE_NEGATIVE", "DOUBLE_POSITIVE", "DROP", "ECHAR", "ENCODE_FOR_URI", "EOL", "EQUAL", "EXISTS", "EXPONENT", "EXPRESSION_LIST", "FALSE", "FILTER", "FLOOR", "FROM", "FUNCTION", "GRAPH", "GREATER", "GREATER_EQUAL", "GROUP", "GROUP_BY", "GROUP_CONCAT", "GROUP_CONDITION", "GROUP_GRAPH_PATTERN", "HAVING", "HOURS", "IF", "IN", "INSERT", "INTEGER", "INTEGER_NEGATIVE", "INTEGER_POSITIVE", "INTO", "INVERSE", "IRI", "IRI_REF", "IRI_REF_CHARACTERS", "ISBLANK", "ISIRI", "ISLITERAL", "ISNUMERIC", "ISURI", "LANG", "LANGMATCHES", "LANGTAG", "LCASE", "LESS", "LESS_EQUAL", "LIMIT", "LOAD", "MAX", "MD5", "MIN", "MINUS", "MINUS_KEYWORD", "MINUTES", "MODIFY", "MONTH", "MOVE", "NAMED", "NEGATION", "NOT", "NOT_EQUAL", "NOT_EXISTS", "NOW", "OBJECT", "OFFSET", "OPEN_BRACE", "OPEN_CURLY_BRACE", "OPEN_SQUARE_BRACKET", "OPTIONAL", "OR", "ORDER", "ORDER_BY", "ORDER_CONDITION", "PATH", "PATH_NEGATED", "PATH_PRIMARY", "PATH_SEQUENCE", "PIPE", "PLUS", "PNAME_LN", "PNAME_NS", "PN_CHARS", "PN_CHARS_BASE", "PN_CHARS_U", "PN_LOCAL", "PN_PREFIX", "PREDICATE", "PREFIX", "PROLOGUE", "QUERY", "QUESTION_MARK", "RAND", "REDUCED", "REFERENCE", "REGEX", "REPLACE", "ROUND", "SAMETERM", "SAMPLE", "SECONDS", "SELECT", "SELECT_CLAUSE", "SEMICOLON", "SEPARATOR", "SERVICE", "SHA1", "SHA224", "SHA256", "SHA384", "SHA512", "SIGN", "SILENT", "STR", "STRAFTER", "STRBEFORE", "STRDT", "STRENDS", "STRING_LITERAL1", "STRING_LITERAL2", "STRING_LITERAL_LONG1", "STRING_LITERAL_LONG2", "STRLANG", "STRLEN", "STRSTARTS", "SUBJECT", "SUBSELECT", "SUBSTR", "SUM", "TIMEZONE", "TO", "TRIPLES_BLOCK", "TRIPLES_NODE", "TRIPLES_SAME_SUBJECT", "TRIPLES_TEMPLATE", "TRUE", "TZ", "UCASE", "UNARY", "UNDEF", "UNION", "UPDATE", "URI", "USING", "VAR", "VAR1", "VAR2", "VARNAME", "WHERE", "WHERE_CLAUSE", "WITH", "WS", "YEAR"
 24  
     };
 25  
 
 26  
     public static final int EOF=-1;
 27  
     public static final int A=4;
 28  
     public static final int ABS=5;
 29  
     public static final int ADD=6;
 30  
     public static final int ALL=7;
 31  
     public static final int AND=8;
 32  
     public static final int ANY=9;
 33  
     public static final int ARG_LIST=10;
 34  
     public static final int AS=11;
 35  
     public static final int ASC=12;
 36  
     public static final int ASK=13;
 37  
     public static final int ASTERISK=14;
 38  
     public static final int AVG=15;
 39  
     public static final int BASE=16;
 40  
     public static final int BIND=17;
 41  
     public static final int BINDINGS=18;
 42  
     public static final int BINDING_VALUE=19;
 43  
     public static final int BLANK_NODE=20;
 44  
     public static final int BLANK_NODE_LABEL=21;
 45  
     public static final int BNODE=22;
 46  
     public static final int BOUND=23;
 47  
     public static final int BRACKETTED_EXPRESSION=24;
 48  
     public static final int BY=25;
 49  
     public static final int CEIL=26;
 50  
     public static final int CLEAR=27;
 51  
     public static final int CLOSE_BRACE=28;
 52  
     public static final int CLOSE_CURLY_BRACE=29;
 53  
     public static final int CLOSE_SQUARE_BRACKET=30;
 54  
     public static final int COALESCE=31;
 55  
     public static final int COLLECTION=32;
 56  
     public static final int COMMA=33;
 57  
     public static final int COMMENT=34;
 58  
     public static final int CONCAT=35;
 59  
     public static final int CONSTRUCT=36;
 60  
     public static final int CONSTRUCT_TRIPLES=37;
 61  
     public static final int CONTAINS=38;
 62  
     public static final int COPY=39;
 63  
     public static final int COUNT=40;
 64  
     public static final int CREATE=41;
 65  
     public static final int DATA=42;
 66  
     public static final int DATATYPE=43;
 67  
     public static final int DAY=44;
 68  
     public static final int DECIMAL=45;
 69  
     public static final int DECIMAL_NEGATIVE=46;
 70  
     public static final int DECIMAL_POSITIVE=47;
 71  
     public static final int DEFAULT=48;
 72  
     public static final int DELETE=49;
 73  
     public static final int DESC=50;
 74  
     public static final int DESCRIBE=51;
 75  
     public static final int DIGIT=52;
 76  
     public static final int DISTINCT=53;
 77  
     public static final int DIVIDE=54;
 78  
     public static final int DOT=55;
 79  
     public static final int DOUBLE=56;
 80  
     public static final int DOUBLE_NEGATIVE=57;
 81  
     public static final int DOUBLE_POSITIVE=58;
 82  
     public static final int DROP=59;
 83  
     public static final int ECHAR=60;
 84  
     public static final int ENCODE_FOR_URI=61;
 85  
     public static final int EOL=62;
 86  
     public static final int EQUAL=63;
 87  
     public static final int EXISTS=64;
 88  
     public static final int EXPONENT=65;
 89  
     public static final int EXPRESSION_LIST=66;
 90  
     public static final int FALSE=67;
 91  
     public static final int FILTER=68;
 92  
     public static final int FLOOR=69;
 93  
     public static final int FROM=70;
 94  
     public static final int FUNCTION=71;
 95  
     public static final int GRAPH=72;
 96  
     public static final int GREATER=73;
 97  
     public static final int GREATER_EQUAL=74;
 98  
     public static final int GROUP=75;
 99  
     public static final int GROUP_BY=76;
 100  
     public static final int GROUP_CONCAT=77;
 101  
     public static final int GROUP_CONDITION=78;
 102  
     public static final int GROUP_GRAPH_PATTERN=79;
 103  
     public static final int HAVING=80;
 104  
     public static final int HOURS=81;
 105  
     public static final int IF=82;
 106  
     public static final int IN=83;
 107  
     public static final int INSERT=84;
 108  
     public static final int INTEGER=85;
 109  
     public static final int INTEGER_NEGATIVE=86;
 110  
     public static final int INTEGER_POSITIVE=87;
 111  
     public static final int INTO=88;
 112  
     public static final int INVERSE=89;
 113  
     public static final int IRI=90;
 114  
     public static final int IRI_REF=91;
 115  
     public static final int IRI_REF_CHARACTERS=92;
 116  
     public static final int ISBLANK=93;
 117  
     public static final int ISIRI=94;
 118  
     public static final int ISLITERAL=95;
 119  
     public static final int ISNUMERIC=96;
 120  
     public static final int ISURI=97;
 121  
     public static final int LANG=98;
 122  
     public static final int LANGMATCHES=99;
 123  
     public static final int LANGTAG=100;
 124  
     public static final int LCASE=101;
 125  
     public static final int LESS=102;
 126  
     public static final int LESS_EQUAL=103;
 127  
     public static final int LIMIT=104;
 128  
     public static final int LOAD=105;
 129  
     public static final int MAX=106;
 130  
     public static final int MD5=107;
 131  
     public static final int MIN=108;
 132  
     public static final int MINUS=109;
 133  
     public static final int MINUS_KEYWORD=110;
 134  
     public static final int MINUTES=111;
 135  
     public static final int MODIFY=112;
 136  
     public static final int MONTH=113;
 137  
     public static final int MOVE=114;
 138  
     public static final int NAMED=115;
 139  
     public static final int NEGATION=116;
 140  
     public static final int NOT=117;
 141  
     public static final int NOT_EQUAL=118;
 142  
     public static final int NOT_EXISTS=119;
 143  
     public static final int NOW=120;
 144  
     public static final int OBJECT=121;
 145  
     public static final int OFFSET=122;
 146  
     public static final int OPEN_BRACE=123;
 147  
     public static final int OPEN_CURLY_BRACE=124;
 148  
     public static final int OPEN_SQUARE_BRACKET=125;
 149  
     public static final int OPTIONAL=126;
 150  
     public static final int OR=127;
 151  
     public static final int ORDER=128;
 152  
     public static final int ORDER_BY=129;
 153  
     public static final int ORDER_CONDITION=130;
 154  
     public static final int PATH=131;
 155  
     public static final int PATH_NEGATED=132;
 156  
     public static final int PATH_PRIMARY=133;
 157  
     public static final int PATH_SEQUENCE=134;
 158  
     public static final int PIPE=135;
 159  
     public static final int PLUS=136;
 160  
     public static final int PNAME_LN=137;
 161  
     public static final int PNAME_NS=138;
 162  
     public static final int PN_CHARS=139;
 163  
     public static final int PN_CHARS_BASE=140;
 164  
     public static final int PN_CHARS_U=141;
 165  
     public static final int PN_LOCAL=142;
 166  
     public static final int PN_PREFIX=143;
 167  
     public static final int PREDICATE=144;
 168  
     public static final int PREFIX=145;
 169  
     public static final int PROLOGUE=146;
 170  
     public static final int QUERY=147;
 171  
     public static final int QUESTION_MARK=148;
 172  
     public static final int RAND=149;
 173  
     public static final int REDUCED=150;
 174  
     public static final int REFERENCE=151;
 175  
     public static final int REGEX=152;
 176  
     public static final int REPLACE=153;
 177  
     public static final int ROUND=154;
 178  
     public static final int SAMETERM=155;
 179  
     public static final int SAMPLE=156;
 180  
     public static final int SECONDS=157;
 181  
     public static final int SELECT=158;
 182  
     public static final int SELECT_CLAUSE=159;
 183  
     public static final int SEMICOLON=160;
 184  
     public static final int SEPARATOR=161;
 185  
     public static final int SERVICE=162;
 186  
     public static final int SHA1=163;
 187  
     public static final int SHA224=164;
 188  
     public static final int SHA256=165;
 189  
     public static final int SHA384=166;
 190  
     public static final int SHA512=167;
 191  
     public static final int SIGN=168;
 192  
     public static final int SILENT=169;
 193  
     public static final int STR=170;
 194  
     public static final int STRAFTER=171;
 195  
     public static final int STRBEFORE=172;
 196  
     public static final int STRDT=173;
 197  
     public static final int STRENDS=174;
 198  
     public static final int STRING_LITERAL1=175;
 199  
     public static final int STRING_LITERAL2=176;
 200  
     public static final int STRING_LITERAL_LONG1=177;
 201  
     public static final int STRING_LITERAL_LONG2=178;
 202  
     public static final int STRLANG=179;
 203  
     public static final int STRLEN=180;
 204  
     public static final int STRSTARTS=181;
 205  
     public static final int SUBJECT=182;
 206  
     public static final int SUBSELECT=183;
 207  
     public static final int SUBSTR=184;
 208  
     public static final int SUM=185;
 209  
     public static final int TIMEZONE=186;
 210  
     public static final int TO=187;
 211  
     public static final int TRIPLES_BLOCK=188;
 212  
     public static final int TRIPLES_NODE=189;
 213  
     public static final int TRIPLES_SAME_SUBJECT=190;
 214  
     public static final int TRIPLES_TEMPLATE=191;
 215  
     public static final int TRUE=192;
 216  
     public static final int TZ=193;
 217  
     public static final int UCASE=194;
 218  
     public static final int UNARY=195;
 219  
     public static final int UNDEF=196;
 220  
     public static final int UNION=197;
 221  
     public static final int UPDATE=198;
 222  
     public static final int URI=199;
 223  
     public static final int USING=200;
 224  
     public static final int VAR=201;
 225  
     public static final int VAR1=202;
 226  
     public static final int VAR2=203;
 227  
     public static final int VARNAME=204;
 228  
     public static final int WHERE=205;
 229  
     public static final int WHERE_CLAUSE=206;
 230  
     public static final int WITH=207;
 231  
     public static final int WS=208;
 232  
     public static final int YEAR=209;
 233  
 
 234  
     // delegates
 235  
     public Parser[] getDelegates() {
 236  0
         return new Parser[] {};
 237  
     }
 238  
 
 239  
     // delegators
 240  
 
 241  
 
 242  
     public SparqlParser(TokenStream input) {
 243  1898
         this(input, new RecognizerSharedState());
 244  1898
     }
 245  
     public SparqlParser(TokenStream input, RecognizerSharedState state) {
 246  1898
         super(input, state);
 247  1898
     }
 248  
 
 249  1898
 protected TreeAdaptor adaptor = new CommonTreeAdaptor();
 250  
 
 251  
 public void setTreeAdaptor(TreeAdaptor adaptor) {
 252  0
     this.adaptor = adaptor;
 253  0
 }
 254  
 public TreeAdaptor getTreeAdaptor() {
 255  0
     return adaptor;
 256  
 }
 257  1
     public String[] getTokenNames() { return SparqlParser.tokenNames; }
 258  0
     public String getGrammarFileName() { return "com\\googlecode\\sparkleg\\Sparql.g"; }
 259  
 
 260  
 
 261  1898
     public static class query_return extends ParserRuleReturnScope {
 262  
         Object tree;
 263  1898
         public Object getTree() { return tree; }
 264  
     };
 265  
 
 266  
 
 267  
     // $ANTLR start "query"
 268  
     // com\\googlecode\\sparkleg\\Sparql.g:76:1: query : ( prologue ( selectQuery | constructQuery | describeQuery | askQuery ) bindingsClause EOF -> ^( QUERY prologue ( selectQuery )* ( constructQuery )* ( describeQuery )* ( askQuery )* ) ( bindingsClause )* | update ( SEMICOLON ( update )? )* EOF -> ^( UPDATE ( update )+ ) );
 269  
     public final SparqlParser.query_return query() throws RecognitionException {
 270  1898
         SparqlParser.query_return retval = new SparqlParser.query_return();
 271  1898
         retval.start = input.LT(1);
 272  
 
 273  
 
 274  1898
         Object root_0 = null;
 275  
 
 276  1898
         Token EOF7=null;
 277  1898
         Token SEMICOLON9=null;
 278  1898
         Token EOF11=null;
 279  1898
         SparqlParser.prologue_return prologue1 =null;
 280  
 
 281  1898
         SparqlParser.selectQuery_return selectQuery2 =null;
 282  
 
 283  1898
         SparqlParser.constructQuery_return constructQuery3 =null;
 284  
 
 285  1898
         SparqlParser.describeQuery_return describeQuery4 =null;
 286  
 
 287  1898
         SparqlParser.askQuery_return askQuery5 =null;
 288  
 
 289  1898
         SparqlParser.bindingsClause_return bindingsClause6 =null;
 290  
 
 291  1898
         SparqlParser.update_return update8 =null;
 292  
 
 293  1898
         SparqlParser.update_return update10 =null;
 294  
 
 295  
 
 296  1898
         Object EOF7_tree=null;
 297  1898
         Object SEMICOLON9_tree=null;
 298  1898
         Object EOF11_tree=null;
 299  1898
         RewriteRuleTokenStream stream_SEMICOLON=new RewriteRuleTokenStream(adaptor,"token SEMICOLON");
 300  1898
         RewriteRuleTokenStream stream_EOF=new RewriteRuleTokenStream(adaptor,"token EOF");
 301  1898
         RewriteRuleSubtreeStream stream_update=new RewriteRuleSubtreeStream(adaptor,"rule update");
 302  1898
         RewriteRuleSubtreeStream stream_describeQuery=new RewriteRuleSubtreeStream(adaptor,"rule describeQuery");
 303  1898
         RewriteRuleSubtreeStream stream_bindingsClause=new RewriteRuleSubtreeStream(adaptor,"rule bindingsClause");
 304  1898
         RewriteRuleSubtreeStream stream_constructQuery=new RewriteRuleSubtreeStream(adaptor,"rule constructQuery");
 305  1898
         RewriteRuleSubtreeStream stream_askQuery=new RewriteRuleSubtreeStream(adaptor,"rule askQuery");
 306  1898
         RewriteRuleSubtreeStream stream_prologue=new RewriteRuleSubtreeStream(adaptor,"rule prologue");
 307  1898
         RewriteRuleSubtreeStream stream_selectQuery=new RewriteRuleSubtreeStream(adaptor,"rule selectQuery");
 308  
         try {
 309  
             // com\\googlecode\\sparkleg\\Sparql.g:77:5: ( prologue ( selectQuery | constructQuery | describeQuery | askQuery ) bindingsClause EOF -> ^( QUERY prologue ( selectQuery )* ( constructQuery )* ( describeQuery )* ( askQuery )* ) ( bindingsClause )* | update ( SEMICOLON ( update )? )* EOF -> ^( UPDATE ( update )+ ) )
 310  1898
             int alt4=2;
 311  1898
             alt4 = dfa4.predict(input);
 312  1898
             switch (alt4) {
 313  
                 case 1 :
 314  
                     // com\\googlecode\\sparkleg\\Sparql.g:77:7: prologue ( selectQuery | constructQuery | describeQuery | askQuery ) bindingsClause EOF
 315  
                     {
 316  1774
                     pushFollow(FOLLOW_prologue_in_query155);
 317  1774
                     prologue1=prologue();
 318  
 
 319  1774
                     state._fsp--;
 320  
 
 321  1774
                     stream_prologue.add(prologue1.getTree());
 322  
 
 323  
                     // com\\googlecode\\sparkleg\\Sparql.g:77:16: ( selectQuery | constructQuery | describeQuery | askQuery )
 324  1774
                     int alt1=4;
 325  1774
                     switch ( input.LA(1) ) {
 326  
                     case SELECT:
 327  
                         {
 328  1554
                         alt1=1;
 329  
                         }
 330  1554
                         break;
 331  
                     case CONSTRUCT:
 332  
                         {
 333  70
                         alt1=2;
 334  
                         }
 335  70
                         break;
 336  
                     case DESCRIBE:
 337  
                         {
 338  28
                         alt1=3;
 339  
                         }
 340  28
                         break;
 341  
                     case ASK:
 342  
                         {
 343  122
                         alt1=4;
 344  
                         }
 345  122
                         break;
 346  
                     default:
 347  0
                         NoViableAltException nvae =
 348  
                             new NoViableAltException("", 1, 0, input);
 349  
 
 350  0
                         throw nvae;
 351  
 
 352  
                     }
 353  
 
 354  1774
                     switch (alt1) {
 355  
                         case 1 :
 356  
                             // com\\googlecode\\sparkleg\\Sparql.g:77:17: selectQuery
 357  
                             {
 358  1554
                             pushFollow(FOLLOW_selectQuery_in_query158);
 359  1554
                             selectQuery2=selectQuery();
 360  
 
 361  1554
                             state._fsp--;
 362  
 
 363  1554
                             stream_selectQuery.add(selectQuery2.getTree());
 364  
 
 365  
                             }
 366  1554
                             break;
 367  
                         case 2 :
 368  
                             // com\\googlecode\\sparkleg\\Sparql.g:77:31: constructQuery
 369  
                             {
 370  70
                             pushFollow(FOLLOW_constructQuery_in_query162);
 371  70
                             constructQuery3=constructQuery();
 372  
 
 373  70
                             state._fsp--;
 374  
 
 375  70
                             stream_constructQuery.add(constructQuery3.getTree());
 376  
 
 377  
                             }
 378  70
                             break;
 379  
                         case 3 :
 380  
                             // com\\googlecode\\sparkleg\\Sparql.g:77:48: describeQuery
 381  
                             {
 382  28
                             pushFollow(FOLLOW_describeQuery_in_query166);
 383  28
                             describeQuery4=describeQuery();
 384  
 
 385  28
                             state._fsp--;
 386  
 
 387  28
                             stream_describeQuery.add(describeQuery4.getTree());
 388  
 
 389  
                             }
 390  28
                             break;
 391  
                         case 4 :
 392  
                             // com\\googlecode\\sparkleg\\Sparql.g:77:64: askQuery
 393  
                             {
 394  122
                             pushFollow(FOLLOW_askQuery_in_query170);
 395  122
                             askQuery5=askQuery();
 396  
 
 397  122
                             state._fsp--;
 398  
 
 399  122
                             stream_askQuery.add(askQuery5.getTree());
 400  
 
 401  
                             }
 402  
                             break;
 403  
 
 404  
                     }
 405  
 
 406  
 
 407  1774
                     pushFollow(FOLLOW_bindingsClause_in_query173);
 408  1774
                     bindingsClause6=bindingsClause();
 409  
 
 410  1774
                     state._fsp--;
 411  
 
 412  1774
                     stream_bindingsClause.add(bindingsClause6.getTree());
 413  
 
 414  1774
                     EOF7=(Token)match(input,EOF,FOLLOW_EOF_in_query175);  
 415  1774
                     stream_EOF.add(EOF7);
 416  
 
 417  
 
 418  
                     // AST REWRITE
 419  
                     // elements: bindingsClause, prologue, askQuery, describeQuery, constructQuery, selectQuery
 420  
                     // token labels: 
 421  
                     // rule labels: retval
 422  
                     // token list labels: 
 423  
                     // rule list labels: 
 424  
                     // wildcard labels: 
 425  1774
                     retval.tree = root_0;
 426  1774
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 427  
 
 428  1774
                     root_0 = (Object)adaptor.nil();
 429  
                     // 77:93: -> ^( QUERY prologue ( selectQuery )* ( constructQuery )* ( describeQuery )* ( askQuery )* ) ( bindingsClause )*
 430  
                     {
 431  
                         // com\\googlecode\\sparkleg\\Sparql.g:77:96: ^( QUERY prologue ( selectQuery )* ( constructQuery )* ( describeQuery )* ( askQuery )* )
 432  
                         {
 433  1774
                         Object root_1 = (Object)adaptor.nil();
 434  1774
                         root_1 = (Object)adaptor.becomeRoot(
 435  
                         (Object)adaptor.create(QUERY, "QUERY")
 436  
                         , root_1);
 437  
 
 438  1774
                         adaptor.addChild(root_1, stream_prologue.nextTree());
 439  
 
 440  
                         // com\\googlecode\\sparkleg\\Sparql.g:77:113: ( selectQuery )*
 441  3328
                         while ( stream_selectQuery.hasNext() ) {
 442  1554
                             adaptor.addChild(root_1, stream_selectQuery.nextTree());
 443  
 
 444  
                         }
 445  1774
                         stream_selectQuery.reset();
 446  
 
 447  
                         // com\\googlecode\\sparkleg\\Sparql.g:77:126: ( constructQuery )*
 448  1844
                         while ( stream_constructQuery.hasNext() ) {
 449  70
                             adaptor.addChild(root_1, stream_constructQuery.nextTree());
 450  
 
 451  
                         }
 452  1774
                         stream_constructQuery.reset();
 453  
 
 454  
                         // com\\googlecode\\sparkleg\\Sparql.g:77:142: ( describeQuery )*
 455  1802
                         while ( stream_describeQuery.hasNext() ) {
 456  28
                             adaptor.addChild(root_1, stream_describeQuery.nextTree());
 457  
 
 458  
                         }
 459  1774
                         stream_describeQuery.reset();
 460  
 
 461  
                         // com\\googlecode\\sparkleg\\Sparql.g:77:157: ( askQuery )*
 462  1896
                         while ( stream_askQuery.hasNext() ) {
 463  122
                             adaptor.addChild(root_1, stream_askQuery.nextTree());
 464  
 
 465  
                         }
 466  1774
                         stream_askQuery.reset();
 467  
 
 468  1774
                         adaptor.addChild(root_0, root_1);
 469  
                         }
 470  
 
 471  
                         // com\\googlecode\\sparkleg\\Sparql.g:77:168: ( bindingsClause )*
 472  1800
                         while ( stream_bindingsClause.hasNext() ) {
 473  26
                             adaptor.addChild(root_0, stream_bindingsClause.nextTree());
 474  
 
 475  
                         }
 476  1774
                         stream_bindingsClause.reset();
 477  
 
 478  
                     }
 479  
 
 480  
 
 481  1774
                     retval.tree = root_0;
 482  
 
 483  
                     }
 484  1774
                     break;
 485  
                 case 2 :
 486  
                     // com\\googlecode\\sparkleg\\Sparql.g:78:7: update ( SEMICOLON ( update )? )* EOF
 487  
                     {
 488  124
                     pushFollow(FOLLOW_update_in_query206);
 489  124
                     update8=update();
 490  
 
 491  124
                     state._fsp--;
 492  
 
 493  124
                     stream_update.add(update8.getTree());
 494  
 
 495  
                     // com\\googlecode\\sparkleg\\Sparql.g:78:14: ( SEMICOLON ( update )? )*
 496  
                     loop3:
 497  
                     do {
 498  128
                         int alt3=2;
 499  128
                         switch ( input.LA(1) ) {
 500  
                         case SEMICOLON:
 501  
                             {
 502  4
                             alt3=1;
 503  
                             }
 504  
                             break;
 505  
 
 506  
                         }
 507  
 
 508  128
                         switch (alt3) {
 509  
                             case 1 :
 510  
                                 // com\\googlecode\\sparkleg\\Sparql.g:78:15: SEMICOLON ( update )?
 511  
                                 {
 512  4
                                 SEMICOLON9=(Token)match(input,SEMICOLON,FOLLOW_SEMICOLON_in_query209);  
 513  4
                                 stream_SEMICOLON.add(SEMICOLON9);
 514  
 
 515  
 
 516  
                                 // com\\googlecode\\sparkleg\\Sparql.g:78:25: ( update )?
 517  4
                                 int alt2=2;
 518  4
                                 switch ( input.LA(1) ) {
 519  
                                     case ADD:
 520  
                                     case ASK:
 521  
                                     case BASE:
 522  
                                     case CLEAR:
 523  
                                     case CONSTRUCT:
 524  
                                     case COPY:
 525  
                                     case CREATE:
 526  
                                     case DELETE:
 527  
                                     case DESCRIBE:
 528  
                                     case DROP:
 529  
                                     case INSERT:
 530  
                                     case LOAD:
 531  
                                     case MOVE:
 532  
                                     case PREFIX:
 533  
                                     case SELECT:
 534  
                                     case WITH:
 535  
                                         {
 536  4
                                         alt2=1;
 537  
                                         }
 538  
                                         break;
 539  
                                 }
 540  
 
 541  4
                                 switch (alt2) {
 542  
                                     case 1 :
 543  
                                         // com\\googlecode\\sparkleg\\Sparql.g:78:25: update
 544  
                                         {
 545  4
                                         pushFollow(FOLLOW_update_in_query211);
 546  4
                                         update10=update();
 547  
 
 548  4
                                         state._fsp--;
 549  
 
 550  4
                                         stream_update.add(update10.getTree());
 551  
 
 552  
                                         }
 553  
                                         break;
 554  
 
 555  
                                 }
 556  
 
 557  
 
 558  
                                 }
 559  4
                                 break;
 560  
 
 561  
                             default :
 562  124
                                 break loop3;
 563  
                         }
 564  4
                     } while (true);
 565  
 
 566  
 
 567  124
                     EOF11=(Token)match(input,EOF,FOLLOW_EOF_in_query216);  
 568  124
                     stream_EOF.add(EOF11);
 569  
 
 570  
 
 571  
                     // AST REWRITE
 572  
                     // elements: update
 573  
                     // token labels: 
 574  
                     // rule labels: retval
 575  
                     // token list labels: 
 576  
                     // rule list labels: 
 577  
                     // wildcard labels: 
 578  124
                     retval.tree = root_0;
 579  124
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 580  
 
 581  124
                     root_0 = (Object)adaptor.nil();
 582  
                     // 78:39: -> ^( UPDATE ( update )+ )
 583  
                     {
 584  
                         // com\\googlecode\\sparkleg\\Sparql.g:78:42: ^( UPDATE ( update )+ )
 585  
                         {
 586  124
                         Object root_1 = (Object)adaptor.nil();
 587  124
                         root_1 = (Object)adaptor.becomeRoot(
 588  
                         (Object)adaptor.create(UPDATE, "UPDATE")
 589  
                         , root_1);
 590  
 
 591  124
                         if ( !(stream_update.hasNext()) ) {
 592  0
                             throw new RewriteEarlyExitException();
 593  
                         }
 594  252
                         while ( stream_update.hasNext() ) {
 595  128
                             adaptor.addChild(root_1, stream_update.nextTree());
 596  
 
 597  
                         }
 598  124
                         stream_update.reset();
 599  
 
 600  124
                         adaptor.addChild(root_0, root_1);
 601  
                         }
 602  
 
 603  
                     }
 604  
 
 605  
 
 606  124
                     retval.tree = root_0;
 607  
 
 608  
                     }
 609  
                     break;
 610  
 
 611  
             }
 612  1898
             retval.stop = input.LT(-1);
 613  
 
 614  
 
 615  1898
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 616  1898
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 617  
 
 618  
         }
 619  0
         catch (RecognitionException re) {
 620  0
             reportError(re);
 621  0
             recover(input,re);
 622  0
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 623  
 
 624  
         }
 625  
 
 626  0
         finally {
 627  
                 // do for sure before leaving
 628  1898
         }
 629  1898
         return retval;
 630  
     }
 631  
     // $ANTLR end "query"
 632  
 
 633  
 
 634  1902
     public static class prologue_return extends ParserRuleReturnScope {
 635  
         Object tree;
 636  1902
         public Object getTree() { return tree; }
 637  
     };
 638  
 
 639  
 
 640  
     // $ANTLR start "prologue"
 641  
     // com\\googlecode\\sparkleg\\Sparql.g:81:1: prologue : ( baseDecl | prefixDecl )* -> ^( PROLOGUE ( baseDecl )* ( prefixDecl )* ) ;
 642  
     public final SparqlParser.prologue_return prologue() throws RecognitionException {
 643  1902
         SparqlParser.prologue_return retval = new SparqlParser.prologue_return();
 644  1902
         retval.start = input.LT(1);
 645  
 
 646  
 
 647  1902
         Object root_0 = null;
 648  
 
 649  1902
         SparqlParser.baseDecl_return baseDecl12 =null;
 650  
 
 651  1902
         SparqlParser.prefixDecl_return prefixDecl13 =null;
 652  
 
 653  
 
 654  1902
         RewriteRuleSubtreeStream stream_prefixDecl=new RewriteRuleSubtreeStream(adaptor,"rule prefixDecl");
 655  1902
         RewriteRuleSubtreeStream stream_baseDecl=new RewriteRuleSubtreeStream(adaptor,"rule baseDecl");
 656  
         try {
 657  
             // com\\googlecode\\sparkleg\\Sparql.g:83:5: ( ( baseDecl | prefixDecl )* -> ^( PROLOGUE ( baseDecl )* ( prefixDecl )* ) )
 658  
             // com\\googlecode\\sparkleg\\Sparql.g:83:7: ( baseDecl | prefixDecl )*
 659  
             {
 660  
             // com\\googlecode\\sparkleg\\Sparql.g:83:7: ( baseDecl | prefixDecl )*
 661  
             loop5:
 662  
             do {
 663  4746
                 int alt5=3;
 664  4746
                 switch ( input.LA(1) ) {
 665  
                 case BASE:
 666  
                     {
 667  62
                     alt5=1;
 668  
                     }
 669  62
                     break;
 670  
                 case PREFIX:
 671  
                     {
 672  2782
                     alt5=2;
 673  
                     }
 674  
                     break;
 675  
 
 676  
                 }
 677  
 
 678  4746
                 switch (alt5) {
 679  
                     case 1 :
 680  
                         // com\\googlecode\\sparkleg\\Sparql.g:83:8: baseDecl
 681  
                         {
 682  62
                         pushFollow(FOLLOW_baseDecl_in_prologue249);
 683  62
                         baseDecl12=baseDecl();
 684  
 
 685  62
                         state._fsp--;
 686  
 
 687  62
                         stream_baseDecl.add(baseDecl12.getTree());
 688  
 
 689  
                         }
 690  62
                         break;
 691  
                     case 2 :
 692  
                         // com\\googlecode\\sparkleg\\Sparql.g:83:19: prefixDecl
 693  
                         {
 694  2782
                         pushFollow(FOLLOW_prefixDecl_in_prologue253);
 695  2782
                         prefixDecl13=prefixDecl();
 696  
 
 697  2782
                         state._fsp--;
 698  
 
 699  2782
                         stream_prefixDecl.add(prefixDecl13.getTree());
 700  
 
 701  
                         }
 702  2782
                         break;
 703  
 
 704  
                     default :
 705  1902
                         break loop5;
 706  
                 }
 707  2844
             } while (true);
 708  
 
 709  
 
 710  
             // AST REWRITE
 711  
             // elements: baseDecl, prefixDecl
 712  
             // token labels: 
 713  
             // rule labels: retval
 714  
             // token list labels: 
 715  
             // rule list labels: 
 716  
             // wildcard labels: 
 717  1902
             retval.tree = root_0;
 718  1902
             RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 719  
 
 720  1902
             root_0 = (Object)adaptor.nil();
 721  
             // 83:32: -> ^( PROLOGUE ( baseDecl )* ( prefixDecl )* )
 722  
             {
 723  
                 // com\\googlecode\\sparkleg\\Sparql.g:83:35: ^( PROLOGUE ( baseDecl )* ( prefixDecl )* )
 724  
                 {
 725  1902
                 Object root_1 = (Object)adaptor.nil();
 726  1902
                 root_1 = (Object)adaptor.becomeRoot(
 727  
                 (Object)adaptor.create(PROLOGUE, "PROLOGUE")
 728  
                 , root_1);
 729  
 
 730  
                 // com\\googlecode\\sparkleg\\Sparql.g:83:46: ( baseDecl )*
 731  1964
                 while ( stream_baseDecl.hasNext() ) {
 732  62
                     adaptor.addChild(root_1, stream_baseDecl.nextTree());
 733  
 
 734  
                 }
 735  1902
                 stream_baseDecl.reset();
 736  
 
 737  
                 // com\\googlecode\\sparkleg\\Sparql.g:83:56: ( prefixDecl )*
 738  4684
                 while ( stream_prefixDecl.hasNext() ) {
 739  2782
                     adaptor.addChild(root_1, stream_prefixDecl.nextTree());
 740  
 
 741  
                 }
 742  1902
                 stream_prefixDecl.reset();
 743  
 
 744  1902
                 adaptor.addChild(root_0, root_1);
 745  
                 }
 746  
 
 747  
             }
 748  
 
 749  
 
 750  1902
             retval.tree = root_0;
 751  
 
 752  
             }
 753  
 
 754  1902
             retval.stop = input.LT(-1);
 755  
 
 756  
 
 757  1902
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 758  1902
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 759  
 
 760  
         }
 761  0
         catch (RecognitionException re) {
 762  0
             reportError(re);
 763  0
             recover(input,re);
 764  0
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 765  
 
 766  
         }
 767  
 
 768  0
         finally {
 769  
                 // do for sure before leaving
 770  1902
         }
 771  1902
         return retval;
 772  
     }
 773  
     // $ANTLR end "prologue"
 774  
 
 775  
 
 776  62
     public static class baseDecl_return extends ParserRuleReturnScope {
 777  
         Object tree;
 778  62
         public Object getTree() { return tree; }
 779  
     };
 780  
 
 781  
 
 782  
     // $ANTLR start "baseDecl"
 783  
     // com\\googlecode\\sparkleg\\Sparql.g:86:1: baseDecl : BASE IRI_REF -> ^( BASE IRI_REF ) ;
 784  
     public final SparqlParser.baseDecl_return baseDecl() throws RecognitionException {
 785  62
         SparqlParser.baseDecl_return retval = new SparqlParser.baseDecl_return();
 786  62
         retval.start = input.LT(1);
 787  
 
 788  
 
 789  62
         Object root_0 = null;
 790  
 
 791  62
         Token BASE14=null;
 792  62
         Token IRI_REF15=null;
 793  
 
 794  62
         Object BASE14_tree=null;
 795  62
         Object IRI_REF15_tree=null;
 796  62
         RewriteRuleTokenStream stream_BASE=new RewriteRuleTokenStream(adaptor,"token BASE");
 797  62
         RewriteRuleTokenStream stream_IRI_REF=new RewriteRuleTokenStream(adaptor,"token IRI_REF");
 798  
 
 799  
         try {
 800  
             // com\\googlecode\\sparkleg\\Sparql.g:87:5: ( BASE IRI_REF -> ^( BASE IRI_REF ) )
 801  
             // com\\googlecode\\sparkleg\\Sparql.g:87:7: BASE IRI_REF
 802  
             {
 803  62
             BASE14=(Token)match(input,BASE,FOLLOW_BASE_in_baseDecl284);  
 804  62
             stream_BASE.add(BASE14);
 805  
 
 806  
 
 807  62
             IRI_REF15=(Token)match(input,IRI_REF,FOLLOW_IRI_REF_in_baseDecl286);  
 808  62
             stream_IRI_REF.add(IRI_REF15);
 809  
 
 810  
 
 811  
             // AST REWRITE
 812  
             // elements: IRI_REF, BASE
 813  
             // token labels: 
 814  
             // rule labels: retval
 815  
             // token list labels: 
 816  
             // rule list labels: 
 817  
             // wildcard labels: 
 818  62
             retval.tree = root_0;
 819  62
             RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 820  
 
 821  62
             root_0 = (Object)adaptor.nil();
 822  
             // 87:20: -> ^( BASE IRI_REF )
 823  
             {
 824  
                 // com\\googlecode\\sparkleg\\Sparql.g:87:23: ^( BASE IRI_REF )
 825  
                 {
 826  62
                 Object root_1 = (Object)adaptor.nil();
 827  62
                 root_1 = (Object)adaptor.becomeRoot(
 828  
                 stream_BASE.nextNode()
 829  
                 , root_1);
 830  
 
 831  62
                 adaptor.addChild(root_1, 
 832  
                 stream_IRI_REF.nextNode()
 833  
                 );
 834  
 
 835  62
                 adaptor.addChild(root_0, root_1);
 836  
                 }
 837  
 
 838  
             }
 839  
 
 840  
 
 841  62
             retval.tree = root_0;
 842  
 
 843  
             }
 844  
 
 845  62
             retval.stop = input.LT(-1);
 846  
 
 847  
 
 848  62
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 849  62
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 850  
 
 851  
         }
 852  0
         catch (RecognitionException re) {
 853  0
             reportError(re);
 854  0
             recover(input,re);
 855  0
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 856  
 
 857  
         }
 858  
 
 859  0
         finally {
 860  
                 // do for sure before leaving
 861  62
         }
 862  62
         return retval;
 863  
     }
 864  
     // $ANTLR end "baseDecl"
 865  
 
 866  
 
 867  2782
     public static class prefixDecl_return extends ParserRuleReturnScope {
 868  
         Object tree;
 869  2782
         public Object getTree() { return tree; }
 870  
     };
 871  
 
 872  
 
 873  
     // $ANTLR start "prefixDecl"
 874  
     // com\\googlecode\\sparkleg\\Sparql.g:90:1: prefixDecl : PREFIX PNAME_NS IRI_REF -> ^( PREFIX PNAME_NS IRI_REF ) ;
 875  
     public final SparqlParser.prefixDecl_return prefixDecl() throws RecognitionException {
 876  2782
         SparqlParser.prefixDecl_return retval = new SparqlParser.prefixDecl_return();
 877  2782
         retval.start = input.LT(1);
 878  
 
 879  
 
 880  2782
         Object root_0 = null;
 881  
 
 882  2782
         Token PREFIX16=null;
 883  2782
         Token PNAME_NS17=null;
 884  2782
         Token IRI_REF18=null;
 885  
 
 886  2782
         Object PREFIX16_tree=null;
 887  2782
         Object PNAME_NS17_tree=null;
 888  2782
         Object IRI_REF18_tree=null;
 889  2782
         RewriteRuleTokenStream stream_PREFIX=new RewriteRuleTokenStream(adaptor,"token PREFIX");
 890  2782
         RewriteRuleTokenStream stream_PNAME_NS=new RewriteRuleTokenStream(adaptor,"token PNAME_NS");
 891  2782
         RewriteRuleTokenStream stream_IRI_REF=new RewriteRuleTokenStream(adaptor,"token IRI_REF");
 892  
 
 893  
         try {
 894  
             // com\\googlecode\\sparkleg\\Sparql.g:91:5: ( PREFIX PNAME_NS IRI_REF -> ^( PREFIX PNAME_NS IRI_REF ) )
 895  
             // com\\googlecode\\sparkleg\\Sparql.g:91:7: PREFIX PNAME_NS IRI_REF
 896  
             {
 897  2782
             PREFIX16=(Token)match(input,PREFIX,FOLLOW_PREFIX_in_prefixDecl312);  
 898  2782
             stream_PREFIX.add(PREFIX16);
 899  
 
 900  
 
 901  2782
             PNAME_NS17=(Token)match(input,PNAME_NS,FOLLOW_PNAME_NS_in_prefixDecl314);  
 902  2782
             stream_PNAME_NS.add(PNAME_NS17);
 903  
 
 904  
 
 905  2782
             IRI_REF18=(Token)match(input,IRI_REF,FOLLOW_IRI_REF_in_prefixDecl316);  
 906  2782
             stream_IRI_REF.add(IRI_REF18);
 907  
 
 908  
 
 909  
             // AST REWRITE
 910  
             // elements: PREFIX, IRI_REF, PNAME_NS
 911  
             // token labels: 
 912  
             // rule labels: retval
 913  
             // token list labels: 
 914  
             // rule list labels: 
 915  
             // wildcard labels: 
 916  2782
             retval.tree = root_0;
 917  2782
             RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 918  
 
 919  2782
             root_0 = (Object)adaptor.nil();
 920  
             // 91:31: -> ^( PREFIX PNAME_NS IRI_REF )
 921  
             {
 922  
                 // com\\googlecode\\sparkleg\\Sparql.g:91:34: ^( PREFIX PNAME_NS IRI_REF )
 923  
                 {
 924  2782
                 Object root_1 = (Object)adaptor.nil();
 925  2782
                 root_1 = (Object)adaptor.becomeRoot(
 926  
                 stream_PREFIX.nextNode()
 927  
                 , root_1);
 928  
 
 929  2782
                 adaptor.addChild(root_1, 
 930  
                 stream_PNAME_NS.nextNode()
 931  
                 );
 932  
 
 933  2782
                 adaptor.addChild(root_1, 
 934  
                 stream_IRI_REF.nextNode()
 935  
                 );
 936  
 
 937  2782
                 adaptor.addChild(root_0, root_1);
 938  
                 }
 939  
 
 940  
             }
 941  
 
 942  
 
 943  2782
             retval.tree = root_0;
 944  
 
 945  
             }
 946  
 
 947  2782
             retval.stop = input.LT(-1);
 948  
 
 949  
 
 950  2782
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 951  2782
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 952  
 
 953  
         }
 954  0
         catch (RecognitionException re) {
 955  0
             reportError(re);
 956  0
             recover(input,re);
 957  0
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 958  
 
 959  
         }
 960  
 
 961  0
         finally {
 962  
                 // do for sure before leaving
 963  2782
         }
 964  2782
         return retval;
 965  
     }
 966  
     // $ANTLR end "prefixDecl"
 967  
 
 968  
 
 969  1554
     public static class selectQuery_return extends ParserRuleReturnScope {
 970  
         Object tree;
 971  1554
         public Object getTree() { return tree; }
 972  
     };
 973  
 
 974  
 
 975  
     // $ANTLR start "selectQuery"
 976  
     // com\\googlecode\\sparkleg\\Sparql.g:94:1: selectQuery : selectClause ( datasetClause )* whereClause solutionModifier -> ^( SELECT selectClause ( datasetClause )* ( whereClause )* ( solutionModifier )* ) ;
 977  
     public final SparqlParser.selectQuery_return selectQuery() throws RecognitionException {
 978  1554
         SparqlParser.selectQuery_return retval = new SparqlParser.selectQuery_return();
 979  1554
         retval.start = input.LT(1);
 980  
 
 981  
 
 982  1554
         Object root_0 = null;
 983  
 
 984  1554
         SparqlParser.selectClause_return selectClause19 =null;
 985  
 
 986  1554
         SparqlParser.datasetClause_return datasetClause20 =null;
 987  
 
 988  1554
         SparqlParser.whereClause_return whereClause21 =null;
 989  
 
 990  1554
         SparqlParser.solutionModifier_return solutionModifier22 =null;
 991  
 
 992  
 
 993  1554
         RewriteRuleSubtreeStream stream_whereClause=new RewriteRuleSubtreeStream(adaptor,"rule whereClause");
 994  1554
         RewriteRuleSubtreeStream stream_datasetClause=new RewriteRuleSubtreeStream(adaptor,"rule datasetClause");
 995  1554
         RewriteRuleSubtreeStream stream_solutionModifier=new RewriteRuleSubtreeStream(adaptor,"rule solutionModifier");
 996  1554
         RewriteRuleSubtreeStream stream_selectClause=new RewriteRuleSubtreeStream(adaptor,"rule selectClause");
 997  
         try {
 998  
             // com\\googlecode\\sparkleg\\Sparql.g:95:5: ( selectClause ( datasetClause )* whereClause solutionModifier -> ^( SELECT selectClause ( datasetClause )* ( whereClause )* ( solutionModifier )* ) )
 999  
             // com\\googlecode\\sparkleg\\Sparql.g:95:7: selectClause ( datasetClause )* whereClause solutionModifier
 1000  
             {
 1001  1554
             pushFollow(FOLLOW_selectClause_in_selectQuery343);
 1002  1554
             selectClause19=selectClause();
 1003  
 
 1004  1554
             state._fsp--;
 1005  
 
 1006  1554
             stream_selectClause.add(selectClause19.getTree());
 1007  
 
 1008  
             // com\\googlecode\\sparkleg\\Sparql.g:95:20: ( datasetClause )*
 1009  
             loop6:
 1010  
             do {
 1011  1712
                 int alt6=2;
 1012  1712
                 switch ( input.LA(1) ) {
 1013  
                 case FROM:
 1014  
                     {
 1015  158
                     alt6=1;
 1016  
                     }
 1017  
                     break;
 1018  
 
 1019  
                 }
 1020  
 
 1021  1712
                 switch (alt6) {
 1022  
                     case 1 :
 1023  
                         // com\\googlecode\\sparkleg\\Sparql.g:95:20: datasetClause
 1024  
                         {
 1025  158
                         pushFollow(FOLLOW_datasetClause_in_selectQuery345);
 1026  158
                         datasetClause20=datasetClause();
 1027  
 
 1028  158
                         state._fsp--;
 1029  
 
 1030  158
                         stream_datasetClause.add(datasetClause20.getTree());
 1031  
 
 1032  
                         }
 1033  158
                         break;
 1034  
 
 1035  
                     default :
 1036  1554
                         break loop6;
 1037  
                 }
 1038  158
             } while (true);
 1039  
 
 1040  
 
 1041  1554
             pushFollow(FOLLOW_whereClause_in_selectQuery348);
 1042  1554
             whereClause21=whereClause();
 1043  
 
 1044  1554
             state._fsp--;
 1045  
 
 1046  1554
             stream_whereClause.add(whereClause21.getTree());
 1047  
 
 1048  1554
             pushFollow(FOLLOW_solutionModifier_in_selectQuery350);
 1049  1554
             solutionModifier22=solutionModifier();
 1050  
 
 1051  1554
             state._fsp--;
 1052  
 
 1053  1554
             stream_solutionModifier.add(solutionModifier22.getTree());
 1054  
 
 1055  
             // AST REWRITE
 1056  
             // elements: selectClause, solutionModifier, whereClause, datasetClause
 1057  
             // token labels: 
 1058  
             // rule labels: retval
 1059  
             // token list labels: 
 1060  
             // rule list labels: 
 1061  
             // wildcard labels: 
 1062  1554
             retval.tree = root_0;
 1063  1554
             RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 1064  
 
 1065  1554
             root_0 = (Object)adaptor.nil();
 1066  
             // 95:64: -> ^( SELECT selectClause ( datasetClause )* ( whereClause )* ( solutionModifier )* )
 1067  
             {
 1068  
                 // com\\googlecode\\sparkleg\\Sparql.g:95:67: ^( SELECT selectClause ( datasetClause )* ( whereClause )* ( solutionModifier )* )
 1069  
                 {
 1070  1554
                 Object root_1 = (Object)adaptor.nil();
 1071  1554
                 root_1 = (Object)adaptor.becomeRoot(
 1072  
                 (Object)adaptor.create(SELECT, "SELECT")
 1073  
                 , root_1);
 1074  
 
 1075  1554
                 adaptor.addChild(root_1, stream_selectClause.nextTree());
 1076  
 
 1077  
                 // com\\googlecode\\sparkleg\\Sparql.g:95:89: ( datasetClause )*
 1078  1712
                 while ( stream_datasetClause.hasNext() ) {
 1079  158
                     adaptor.addChild(root_1, stream_datasetClause.nextTree());
 1080  
 
 1081  
                 }
 1082  1554
                 stream_datasetClause.reset();
 1083  
 
 1084  
                 // com\\googlecode\\sparkleg\\Sparql.g:95:104: ( whereClause )*
 1085  3108
                 while ( stream_whereClause.hasNext() ) {
 1086  1554
                     adaptor.addChild(root_1, stream_whereClause.nextTree());
 1087  
 
 1088  
                 }
 1089  1554
                 stream_whereClause.reset();
 1090  
 
 1091  
                 // com\\googlecode\\sparkleg\\Sparql.g:95:117: ( solutionModifier )*
 1092  1742
                 while ( stream_solutionModifier.hasNext() ) {
 1093  188
                     adaptor.addChild(root_1, stream_solutionModifier.nextTree());
 1094  
 
 1095  
                 }
 1096  1554
                 stream_solutionModifier.reset();
 1097  
 
 1098  1554
                 adaptor.addChild(root_0, root_1);
 1099  
                 }
 1100  
 
 1101  
             }
 1102  
 
 1103  
 
 1104  1554
             retval.tree = root_0;
 1105  
 
 1106  
             }
 1107  
 
 1108  1554
             retval.stop = input.LT(-1);
 1109  
 
 1110  
 
 1111  1554
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 1112  1554
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 1113  
 
 1114  
         }
 1115  0
         catch (RecognitionException re) {
 1116  0
             reportError(re);
 1117  0
             recover(input,re);
 1118  0
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 1119  
 
 1120  
         }
 1121  
 
 1122  0
         finally {
 1123  
                 // do for sure before leaving
 1124  1554
         }
 1125  1554
         return retval;
 1126  
     }
 1127  
     // $ANTLR end "selectQuery"
 1128  
 
 1129  
 
 1130  46
     public static class subSelect_return extends ParserRuleReturnScope {
 1131  
         Object tree;
 1132  46
         public Object getTree() { return tree; }
 1133  
     };
 1134  
 
 1135  
 
 1136  
     // $ANTLR start "subSelect"
 1137  
     // com\\googlecode\\sparkleg\\Sparql.g:98:1: subSelect : selectClause whereClause solutionModifier -> ^( SUBSELECT selectClause ( whereClause )* ( solutionModifier )* ) ;
 1138  
     public final SparqlParser.subSelect_return subSelect() throws RecognitionException {
 1139  46
         SparqlParser.subSelect_return retval = new SparqlParser.subSelect_return();
 1140  46
         retval.start = input.LT(1);
 1141  
 
 1142  
 
 1143  46
         Object root_0 = null;
 1144  
 
 1145  46
         SparqlParser.selectClause_return selectClause23 =null;
 1146  
 
 1147  46
         SparqlParser.whereClause_return whereClause24 =null;
 1148  
 
 1149  46
         SparqlParser.solutionModifier_return solutionModifier25 =null;
 1150  
 
 1151  
 
 1152  46
         RewriteRuleSubtreeStream stream_whereClause=new RewriteRuleSubtreeStream(adaptor,"rule whereClause");
 1153  46
         RewriteRuleSubtreeStream stream_solutionModifier=new RewriteRuleSubtreeStream(adaptor,"rule solutionModifier");
 1154  46
         RewriteRuleSubtreeStream stream_selectClause=new RewriteRuleSubtreeStream(adaptor,"rule selectClause");
 1155  
         try {
 1156  
             // com\\googlecode\\sparkleg\\Sparql.g:99:5: ( selectClause whereClause solutionModifier -> ^( SUBSELECT selectClause ( whereClause )* ( solutionModifier )* ) )
 1157  
             // com\\googlecode\\sparkleg\\Sparql.g:99:7: selectClause whereClause solutionModifier
 1158  
             {
 1159  46
             pushFollow(FOLLOW_selectClause_in_subSelect384);
 1160  46
             selectClause23=selectClause();
 1161  
 
 1162  46
             state._fsp--;
 1163  
 
 1164  46
             stream_selectClause.add(selectClause23.getTree());
 1165  
 
 1166  46
             pushFollow(FOLLOW_whereClause_in_subSelect386);
 1167  46
             whereClause24=whereClause();
 1168  
 
 1169  46
             state._fsp--;
 1170  
 
 1171  46
             stream_whereClause.add(whereClause24.getTree());
 1172  
 
 1173  46
             pushFollow(FOLLOW_solutionModifier_in_subSelect388);
 1174  46
             solutionModifier25=solutionModifier();
 1175  
 
 1176  46
             state._fsp--;
 1177  
 
 1178  46
             stream_solutionModifier.add(solutionModifier25.getTree());
 1179  
 
 1180  
             // AST REWRITE
 1181  
             // elements: solutionModifier, selectClause, whereClause
 1182  
             // token labels: 
 1183  
             // rule labels: retval
 1184  
             // token list labels: 
 1185  
             // rule list labels: 
 1186  
             // wildcard labels: 
 1187  46
             retval.tree = root_0;
 1188  46
             RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 1189  
 
 1190  46
             root_0 = (Object)adaptor.nil();
 1191  
             // 99:49: -> ^( SUBSELECT selectClause ( whereClause )* ( solutionModifier )* )
 1192  
             {
 1193  
                 // com\\googlecode\\sparkleg\\Sparql.g:99:52: ^( SUBSELECT selectClause ( whereClause )* ( solutionModifier )* )
 1194  
                 {
 1195  46
                 Object root_1 = (Object)adaptor.nil();
 1196  46
                 root_1 = (Object)adaptor.becomeRoot(
 1197  
                 (Object)adaptor.create(SUBSELECT, "SUBSELECT")
 1198  
                 , root_1);
 1199  
 
 1200  46
                 adaptor.addChild(root_1, stream_selectClause.nextTree());
 1201  
 
 1202  
                 // com\\googlecode\\sparkleg\\Sparql.g:99:77: ( whereClause )*
 1203  92
                 while ( stream_whereClause.hasNext() ) {
 1204  46
                     adaptor.addChild(root_1, stream_whereClause.nextTree());
 1205  
 
 1206  
                 }
 1207  46
                 stream_whereClause.reset();
 1208  
 
 1209  
                 // com\\googlecode\\sparkleg\\Sparql.g:99:90: ( solutionModifier )*
 1210  56
                 while ( stream_solutionModifier.hasNext() ) {
 1211  10
                     adaptor.addChild(root_1, stream_solutionModifier.nextTree());
 1212  
 
 1213  
                 }
 1214  46
                 stream_solutionModifier.reset();
 1215  
 
 1216  46
                 adaptor.addChild(root_0, root_1);
 1217  
                 }
 1218  
 
 1219  
             }
 1220  
 
 1221  
 
 1222  46
             retval.tree = root_0;
 1223  
 
 1224  
             }
 1225  
 
 1226  46
             retval.stop = input.LT(-1);
 1227  
 
 1228  
 
 1229  46
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 1230  46
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 1231  
 
 1232  
         }
 1233  0
         catch (RecognitionException re) {
 1234  0
             reportError(re);
 1235  0
             recover(input,re);
 1236  0
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 1237  
 
 1238  
         }
 1239  
 
 1240  0
         finally {
 1241  
                 // do for sure before leaving
 1242  46
         }
 1243  46
         return retval;
 1244  
     }
 1245  
     // $ANTLR end "subSelect"
 1246  
 
 1247  
 
 1248  1600
     public static class selectClause_return extends ParserRuleReturnScope {
 1249  
         Object tree;
 1250  1600
         public Object getTree() { return tree; }
 1251  
     };
 1252  
 
 1253  
 
 1254  
     // $ANTLR start "selectClause"
 1255  
     // com\\googlecode\\sparkleg\\Sparql.g:102:1: selectClause : ( SELECT ( DISTINCT | REDUCED )? ASTERISK -> ^( SELECT_CLAUSE ( DISTINCT )* ( REDUCED )* ASTERISK ) | SELECT ( DISTINCT | REDUCED )? (v+= selectVariables )+ -> ^( SELECT_CLAUSE ( DISTINCT )* ( REDUCED )* ( $v)* ) );
 1256  
     public final SparqlParser.selectClause_return selectClause() throws RecognitionException {
 1257  1600
         SparqlParser.selectClause_return retval = new SparqlParser.selectClause_return();
 1258  1600
         retval.start = input.LT(1);
 1259  
 
 1260  
 
 1261  1600
         Object root_0 = null;
 1262  
 
 1263  1600
         Token SELECT26=null;
 1264  1600
         Token DISTINCT27=null;
 1265  1600
         Token REDUCED28=null;
 1266  1600
         Token ASTERISK29=null;
 1267  1600
         Token SELECT30=null;
 1268  1600
         Token DISTINCT31=null;
 1269  1600
         Token REDUCED32=null;
 1270  1600
         List list_v=null;
 1271  1600
         RuleReturnScope v = null;
 1272  1600
         Object SELECT26_tree=null;
 1273  1600
         Object DISTINCT27_tree=null;
 1274  1600
         Object REDUCED28_tree=null;
 1275  1600
         Object ASTERISK29_tree=null;
 1276  1600
         Object SELECT30_tree=null;
 1277  1600
         Object DISTINCT31_tree=null;
 1278  1600
         Object REDUCED32_tree=null;
 1279  1600
         RewriteRuleTokenStream stream_SELECT=new RewriteRuleTokenStream(adaptor,"token SELECT");
 1280  1600
         RewriteRuleTokenStream stream_DISTINCT=new RewriteRuleTokenStream(adaptor,"token DISTINCT");
 1281  1600
         RewriteRuleTokenStream stream_REDUCED=new RewriteRuleTokenStream(adaptor,"token REDUCED");
 1282  1600
         RewriteRuleTokenStream stream_ASTERISK=new RewriteRuleTokenStream(adaptor,"token ASTERISK");
 1283  1600
         RewriteRuleSubtreeStream stream_selectVariables=new RewriteRuleSubtreeStream(adaptor,"rule selectVariables");
 1284  
         try {
 1285  
             // com\\googlecode\\sparkleg\\Sparql.g:103:5: ( SELECT ( DISTINCT | REDUCED )? ASTERISK -> ^( SELECT_CLAUSE ( DISTINCT )* ( REDUCED )* ASTERISK ) | SELECT ( DISTINCT | REDUCED )? (v+= selectVariables )+ -> ^( SELECT_CLAUSE ( DISTINCT )* ( REDUCED )* ( $v)* ) )
 1286  1600
             int alt10=2;
 1287  1600
             switch ( input.LA(1) ) {
 1288  
             case SELECT:
 1289  
                 {
 1290  1600
                 switch ( input.LA(2) ) {
 1291  
                 case DISTINCT:
 1292  
                     {
 1293  44
                     switch ( input.LA(3) ) {
 1294  
                     case ASTERISK:
 1295  
                         {
 1296  2
                         alt10=1;
 1297  
                         }
 1298  2
                         break;
 1299  
                     case OPEN_BRACE:
 1300  
                     case VAR1:
 1301  
                     case VAR2:
 1302  
                         {
 1303  42
                         alt10=2;
 1304  
                         }
 1305  42
                         break;
 1306  
                     default:
 1307  0
                         NoViableAltException nvae =
 1308  
                             new NoViableAltException("", 10, 2, input);
 1309  
 
 1310  0
                         throw nvae;
 1311  
 
 1312  
                     }
 1313  
 
 1314  
                     }
 1315  44
                     break;
 1316  
                 case REDUCED:
 1317  
                     {
 1318  14
                     switch ( input.LA(3) ) {
 1319  
                     case ASTERISK:
 1320  
                         {
 1321  4
                         alt10=1;
 1322  
                         }
 1323  4
                         break;
 1324  
                     case OPEN_BRACE:
 1325  
                     case VAR1:
 1326  
                     case VAR2:
 1327  
                         {
 1328  10
                         alt10=2;
 1329  
                         }
 1330  10
                         break;
 1331  
                     default:
 1332  0
                         NoViableAltException nvae =
 1333  
                             new NoViableAltException("", 10, 3, input);
 1334  
 
 1335  0
                         throw nvae;
 1336  
 
 1337  
                     }
 1338  
 
 1339  
                     }
 1340  14
                     break;
 1341  
                 case ASTERISK:
 1342  
                     {
 1343  612
                     alt10=1;
 1344  
                     }
 1345  612
                     break;
 1346  
                 case OPEN_BRACE:
 1347  
                 case VAR1:
 1348  
                 case VAR2:
 1349  
                     {
 1350  930
                     alt10=2;
 1351  
                     }
 1352  930
                     break;
 1353  
                 default:
 1354  0
                     NoViableAltException nvae =
 1355  
                         new NoViableAltException("", 10, 1, input);
 1356  
 
 1357  0
                     throw nvae;
 1358  
 
 1359  
                 }
 1360  
 
 1361  
                 }
 1362  1600
                 break;
 1363  
             default:
 1364  0
                 NoViableAltException nvae =
 1365  
                     new NoViableAltException("", 10, 0, input);
 1366  
 
 1367  0
                 throw nvae;
 1368  
 
 1369  
             }
 1370  
 
 1371  1600
             switch (alt10) {
 1372  
                 case 1 :
 1373  
                     // com\\googlecode\\sparkleg\\Sparql.g:103:7: SELECT ( DISTINCT | REDUCED )? ASTERISK
 1374  
                     {
 1375  618
                     SELECT26=(Token)match(input,SELECT,FOLLOW_SELECT_in_selectClause424);  
 1376  618
                     stream_SELECT.add(SELECT26);
 1377  
 
 1378  
 
 1379  
                     // com\\googlecode\\sparkleg\\Sparql.g:103:14: ( DISTINCT | REDUCED )?
 1380  618
                     int alt7=3;
 1381  618
                     switch ( input.LA(1) ) {
 1382  
                         case DISTINCT:
 1383  
                             {
 1384  2
                             alt7=1;
 1385  
                             }
 1386  2
                             break;
 1387  
                         case REDUCED:
 1388  
                             {
 1389  4
                             alt7=2;
 1390  
                             }
 1391  
                             break;
 1392  
                     }
 1393  
 
 1394  618
                     switch (alt7) {
 1395  
                         case 1 :
 1396  
                             // com\\googlecode\\sparkleg\\Sparql.g:103:15: DISTINCT
 1397  
                             {
 1398  2
                             DISTINCT27=(Token)match(input,DISTINCT,FOLLOW_DISTINCT_in_selectClause427);  
 1399  2
                             stream_DISTINCT.add(DISTINCT27);
 1400  
 
 1401  
 
 1402  
                             }
 1403  2
                             break;
 1404  
                         case 2 :
 1405  
                             // com\\googlecode\\sparkleg\\Sparql.g:103:26: REDUCED
 1406  
                             {
 1407  4
                             REDUCED28=(Token)match(input,REDUCED,FOLLOW_REDUCED_in_selectClause431);  
 1408  4
                             stream_REDUCED.add(REDUCED28);
 1409  
 
 1410  
 
 1411  
                             }
 1412  
                             break;
 1413  
 
 1414  
                     }
 1415  
 
 1416  
 
 1417  618
                     ASTERISK29=(Token)match(input,ASTERISK,FOLLOW_ASTERISK_in_selectClause435);  
 1418  618
                     stream_ASTERISK.add(ASTERISK29);
 1419  
 
 1420  
 
 1421  
                     // AST REWRITE
 1422  
                     // elements: ASTERISK, REDUCED, DISTINCT
 1423  
                     // token labels: 
 1424  
                     // rule labels: retval
 1425  
                     // token list labels: 
 1426  
                     // rule list labels: 
 1427  
                     // wildcard labels: 
 1428  618
                     retval.tree = root_0;
 1429  618
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 1430  
 
 1431  618
                     root_0 = (Object)adaptor.nil();
 1432  
                     // 103:45: -> ^( SELECT_CLAUSE ( DISTINCT )* ( REDUCED )* ASTERISK )
 1433  
                     {
 1434  
                         // com\\googlecode\\sparkleg\\Sparql.g:103:48: ^( SELECT_CLAUSE ( DISTINCT )* ( REDUCED )* ASTERISK )
 1435  
                         {
 1436  618
                         Object root_1 = (Object)adaptor.nil();
 1437  618
                         root_1 = (Object)adaptor.becomeRoot(
 1438  
                         (Object)adaptor.create(SELECT_CLAUSE, "SELECT_CLAUSE")
 1439  
                         , root_1);
 1440  
 
 1441  
                         // com\\googlecode\\sparkleg\\Sparql.g:103:64: ( DISTINCT )*
 1442  620
                         while ( stream_DISTINCT.hasNext() ) {
 1443  2
                             adaptor.addChild(root_1, 
 1444  
                             stream_DISTINCT.nextNode()
 1445  
                             );
 1446  
 
 1447  
                         }
 1448  618
                         stream_DISTINCT.reset();
 1449  
 
 1450  
                         // com\\googlecode\\sparkleg\\Sparql.g:103:74: ( REDUCED )*
 1451  622
                         while ( stream_REDUCED.hasNext() ) {
 1452  4
                             adaptor.addChild(root_1, 
 1453  
                             stream_REDUCED.nextNode()
 1454  
                             );
 1455  
 
 1456  
                         }
 1457  618
                         stream_REDUCED.reset();
 1458  
 
 1459  618
                         adaptor.addChild(root_1, 
 1460  
                         stream_ASTERISK.nextNode()
 1461  
                         );
 1462  
 
 1463  618
                         adaptor.addChild(root_0, root_1);
 1464  
                         }
 1465  
 
 1466  
                     }
 1467  
 
 1468  
 
 1469  618
                     retval.tree = root_0;
 1470  
 
 1471  
                     }
 1472  618
                     break;
 1473  
                 case 2 :
 1474  
                     // com\\googlecode\\sparkleg\\Sparql.g:104:7: SELECT ( DISTINCT | REDUCED )? (v+= selectVariables )+
 1475  
                     {
 1476  982
                     SELECT30=(Token)match(input,SELECT,FOLLOW_SELECT_in_selectClause457);  
 1477  982
                     stream_SELECT.add(SELECT30);
 1478  
 
 1479  
 
 1480  
                     // com\\googlecode\\sparkleg\\Sparql.g:104:14: ( DISTINCT | REDUCED )?
 1481  982
                     int alt8=3;
 1482  982
                     switch ( input.LA(1) ) {
 1483  
                         case DISTINCT:
 1484  
                             {
 1485  42
                             alt8=1;
 1486  
                             }
 1487  42
                             break;
 1488  
                         case REDUCED:
 1489  
                             {
 1490  10
                             alt8=2;
 1491  
                             }
 1492  
                             break;
 1493  
                     }
 1494  
 
 1495  982
                     switch (alt8) {
 1496  
                         case 1 :
 1497  
                             // com\\googlecode\\sparkleg\\Sparql.g:104:15: DISTINCT
 1498  
                             {
 1499  42
                             DISTINCT31=(Token)match(input,DISTINCT,FOLLOW_DISTINCT_in_selectClause460);  
 1500  42
                             stream_DISTINCT.add(DISTINCT31);
 1501  
 
 1502  
 
 1503  
                             }
 1504  42
                             break;
 1505  
                         case 2 :
 1506  
                             // com\\googlecode\\sparkleg\\Sparql.g:104:26: REDUCED
 1507  
                             {
 1508  10
                             REDUCED32=(Token)match(input,REDUCED,FOLLOW_REDUCED_in_selectClause464);  
 1509  10
                             stream_REDUCED.add(REDUCED32);
 1510  
 
 1511  
 
 1512  
                             }
 1513  
                             break;
 1514  
 
 1515  
                     }
 1516  
 
 1517  
 
 1518  
                     // com\\googlecode\\sparkleg\\Sparql.g:104:36: (v+= selectVariables )+
 1519  982
                     int cnt9=0;
 1520  
                     loop9:
 1521  
                     do {
 1522  2648
                         int alt9=2;
 1523  2648
                         switch ( input.LA(1) ) {
 1524  
                         case OPEN_BRACE:
 1525  
                         case VAR1:
 1526  
                         case VAR2:
 1527  
                             {
 1528  1666
                             alt9=1;
 1529  
                             }
 1530  
                             break;
 1531  
 
 1532  
                         }
 1533  
 
 1534  2648
                         switch (alt9) {
 1535  
                             case 1 :
 1536  
                                 // com\\googlecode\\sparkleg\\Sparql.g:104:37: v+= selectVariables
 1537  
                                 {
 1538  1666
                                 pushFollow(FOLLOW_selectVariables_in_selectClause471);
 1539  1666
                                 v=selectVariables();
 1540  
 
 1541  1666
                                 state._fsp--;
 1542  
 
 1543  1666
                                 stream_selectVariables.add(v.getTree());
 1544  1666
                                 if (list_v==null) list_v=new ArrayList();
 1545  1666
                                 list_v.add(v.getTree());
 1546  
 
 1547  
 
 1548  
                                 }
 1549  1666
                                 break;
 1550  
 
 1551  
                             default :
 1552  982
                                 if ( cnt9 >= 1 ) break loop9;
 1553  0
                                 EarlyExitException eee =
 1554  
                                     new EarlyExitException(9, input);
 1555  0
                                 throw eee;
 1556  
                         }
 1557  1666
                         cnt9++;
 1558  1666
                     } while (true);
 1559  
 
 1560  
 
 1561  
                     // AST REWRITE
 1562  
                     // elements: REDUCED, DISTINCT, v
 1563  
                     // token labels: 
 1564  
                     // rule labels: retval
 1565  
                     // token list labels: 
 1566  
                     // rule list labels: v
 1567  
                     // wildcard labels: 
 1568  982
                     retval.tree = root_0;
 1569  982
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 1570  982
                     RewriteRuleSubtreeStream stream_v=new RewriteRuleSubtreeStream(adaptor,"token v",list_v);
 1571  982
                     root_0 = (Object)adaptor.nil();
 1572  
                     // 104:58: -> ^( SELECT_CLAUSE ( DISTINCT )* ( REDUCED )* ( $v)* )
 1573  
                     {
 1574  
                         // com\\googlecode\\sparkleg\\Sparql.g:104:61: ^( SELECT_CLAUSE ( DISTINCT )* ( REDUCED )* ( $v)* )
 1575  
                         {
 1576  982
                         Object root_1 = (Object)adaptor.nil();
 1577  982
                         root_1 = (Object)adaptor.becomeRoot(
 1578  
                         (Object)adaptor.create(SELECT_CLAUSE, "SELECT_CLAUSE")
 1579  
                         , root_1);
 1580  
 
 1581  
                         // com\\googlecode\\sparkleg\\Sparql.g:104:77: ( DISTINCT )*
 1582  1024
                         while ( stream_DISTINCT.hasNext() ) {
 1583  42
                             adaptor.addChild(root_1, 
 1584  
                             stream_DISTINCT.nextNode()
 1585  
                             );
 1586  
 
 1587  
                         }
 1588  982
                         stream_DISTINCT.reset();
 1589  
 
 1590  
                         // com\\googlecode\\sparkleg\\Sparql.g:104:87: ( REDUCED )*
 1591  992
                         while ( stream_REDUCED.hasNext() ) {
 1592  10
                             adaptor.addChild(root_1, 
 1593  
                             stream_REDUCED.nextNode()
 1594  
                             );
 1595  
 
 1596  
                         }
 1597  982
                         stream_REDUCED.reset();
 1598  
 
 1599  
                         // com\\googlecode\\sparkleg\\Sparql.g:104:97: ( $v)*
 1600  2648
                         while ( stream_v.hasNext() ) {
 1601  1666
                             adaptor.addChild(root_1, stream_v.nextTree());
 1602  
 
 1603  
                         }
 1604  982
                         stream_v.reset();
 1605  
 
 1606  982
                         adaptor.addChild(root_0, root_1);
 1607  
                         }
 1608  
 
 1609  
                     }
 1610  
 
 1611  
 
 1612  982
                     retval.tree = root_0;
 1613  
 
 1614  
                     }
 1615  
                     break;
 1616  
 
 1617  
             }
 1618  1600
             retval.stop = input.LT(-1);
 1619  
 
 1620  
 
 1621  1600
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 1622  1600
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 1623  
 
 1624  
         }
 1625  0
         catch (RecognitionException re) {
 1626  0
             reportError(re);
 1627  0
             recover(input,re);
 1628  0
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 1629  
 
 1630  
         }
 1631  
 
 1632  0
         finally {
 1633  
                 // do for sure before leaving
 1634  1600
         }
 1635  1600
         return retval;
 1636  
     }
 1637  
     // $ANTLR end "selectClause"
 1638  
 
 1639  
 
 1640  1666
     public static class selectVariables_return extends ParserRuleReturnScope {
 1641  
         Object tree;
 1642  3332
         public Object getTree() { return tree; }
 1643  
     };
 1644  
 
 1645  
 
 1646  
     // $ANTLR start "selectVariables"
 1647  
     // com\\googlecode\\sparkleg\\Sparql.g:107:1: selectVariables : ( var -> ^( VAR var ) | OPEN_BRACE expression AS var CLOSE_BRACE -> ^( AS expression var ) );
 1648  
     public final SparqlParser.selectVariables_return selectVariables() throws RecognitionException {
 1649  1666
         SparqlParser.selectVariables_return retval = new SparqlParser.selectVariables_return();
 1650  1666
         retval.start = input.LT(1);
 1651  
 
 1652  
 
 1653  1666
         Object root_0 = null;
 1654  
 
 1655  1666
         Token OPEN_BRACE34=null;
 1656  1666
         Token AS36=null;
 1657  1666
         Token CLOSE_BRACE38=null;
 1658  1666
         SparqlParser.var_return var33 =null;
 1659  
 
 1660  1666
         SparqlParser.expression_return expression35 =null;
 1661  
 
 1662  1666
         SparqlParser.var_return var37 =null;
 1663  
 
 1664  
 
 1665  1666
         Object OPEN_BRACE34_tree=null;
 1666  1666
         Object AS36_tree=null;
 1667  1666
         Object CLOSE_BRACE38_tree=null;
 1668  1666
         RewriteRuleTokenStream stream_AS=new RewriteRuleTokenStream(adaptor,"token AS");
 1669  1666
         RewriteRuleTokenStream stream_CLOSE_BRACE=new RewriteRuleTokenStream(adaptor,"token CLOSE_BRACE");
 1670  1666
         RewriteRuleTokenStream stream_OPEN_BRACE=new RewriteRuleTokenStream(adaptor,"token OPEN_BRACE");
 1671  1666
         RewriteRuleSubtreeStream stream_expression=new RewriteRuleSubtreeStream(adaptor,"rule expression");
 1672  1666
         RewriteRuleSubtreeStream stream_var=new RewriteRuleSubtreeStream(adaptor,"rule var");
 1673  
         try {
 1674  
             // com\\googlecode\\sparkleg\\Sparql.g:108:5: ( var -> ^( VAR var ) | OPEN_BRACE expression AS var CLOSE_BRACE -> ^( AS expression var ) )
 1675  1666
             int alt11=2;
 1676  1666
             switch ( input.LA(1) ) {
 1677  
             case VAR1:
 1678  
             case VAR2:
 1679  
                 {
 1680  1416
                 alt11=1;
 1681  
                 }
 1682  1416
                 break;
 1683  
             case OPEN_BRACE:
 1684  
                 {
 1685  250
                 alt11=2;
 1686  
                 }
 1687  250
                 break;
 1688  
             default:
 1689  0
                 NoViableAltException nvae =
 1690  
                     new NoViableAltException("", 11, 0, input);
 1691  
 
 1692  0
                 throw nvae;
 1693  
 
 1694  
             }
 1695  
 
 1696  1666
             switch (alt11) {
 1697  
                 case 1 :
 1698  
                     // com\\googlecode\\sparkleg\\Sparql.g:108:7: var
 1699  
                     {
 1700  1416
                     pushFollow(FOLLOW_var_in_selectVariables506);
 1701  1416
                     var33=var();
 1702  
 
 1703  1416
                     state._fsp--;
 1704  
 
 1705  1416
                     stream_var.add(var33.getTree());
 1706  
 
 1707  
                     // AST REWRITE
 1708  
                     // elements: var
 1709  
                     // token labels: 
 1710  
                     // rule labels: retval
 1711  
                     // token list labels: 
 1712  
                     // rule list labels: 
 1713  
                     // wildcard labels: 
 1714  1416
                     retval.tree = root_0;
 1715  1416
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 1716  
 
 1717  1416
                     root_0 = (Object)adaptor.nil();
 1718  
                     // 108:11: -> ^( VAR var )
 1719  
                     {
 1720  
                         // com\\googlecode\\sparkleg\\Sparql.g:108:14: ^( VAR var )
 1721  
                         {
 1722  1416
                         Object root_1 = (Object)adaptor.nil();
 1723  1416
                         root_1 = (Object)adaptor.becomeRoot(
 1724  
                         (Object)adaptor.create(VAR, "VAR")
 1725  
                         , root_1);
 1726  
 
 1727  1416
                         adaptor.addChild(root_1, stream_var.nextTree());
 1728  
 
 1729  1416
                         adaptor.addChild(root_0, root_1);
 1730  
                         }
 1731  
 
 1732  
                     }
 1733  
 
 1734  
 
 1735  1416
                     retval.tree = root_0;
 1736  
 
 1737  
                     }
 1738  1416
                     break;
 1739  
                 case 2 :
 1740  
                     // com\\googlecode\\sparkleg\\Sparql.g:109:7: OPEN_BRACE expression AS var CLOSE_BRACE
 1741  
                     {
 1742  250
                     OPEN_BRACE34=(Token)match(input,OPEN_BRACE,FOLLOW_OPEN_BRACE_in_selectVariables523);  
 1743  250
                     stream_OPEN_BRACE.add(OPEN_BRACE34);
 1744  
 
 1745  
 
 1746  250
                     pushFollow(FOLLOW_expression_in_selectVariables525);
 1747  250
                     expression35=expression();
 1748  
 
 1749  250
                     state._fsp--;
 1750  
 
 1751  250
                     stream_expression.add(expression35.getTree());
 1752  
 
 1753  250
                     AS36=(Token)match(input,AS,FOLLOW_AS_in_selectVariables527);  
 1754  250
                     stream_AS.add(AS36);
 1755  
 
 1756  
 
 1757  250
                     pushFollow(FOLLOW_var_in_selectVariables529);
 1758  250
                     var37=var();
 1759  
 
 1760  250
                     state._fsp--;
 1761  
 
 1762  250
                     stream_var.add(var37.getTree());
 1763  
 
 1764  250
                     CLOSE_BRACE38=(Token)match(input,CLOSE_BRACE,FOLLOW_CLOSE_BRACE_in_selectVariables531);  
 1765  250
                     stream_CLOSE_BRACE.add(CLOSE_BRACE38);
 1766  
 
 1767  
 
 1768  
                     // AST REWRITE
 1769  
                     // elements: var, expression, AS
 1770  
                     // token labels: 
 1771  
                     // rule labels: retval
 1772  
                     // token list labels: 
 1773  
                     // rule list labels: 
 1774  
                     // wildcard labels: 
 1775  250
                     retval.tree = root_0;
 1776  250
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 1777  
 
 1778  250
                     root_0 = (Object)adaptor.nil();
 1779  
                     // 109:48: -> ^( AS expression var )
 1780  
                     {
 1781  
                         // com\\googlecode\\sparkleg\\Sparql.g:109:51: ^( AS expression var )
 1782  
                         {
 1783  250
                         Object root_1 = (Object)adaptor.nil();
 1784  250
                         root_1 = (Object)adaptor.becomeRoot(
 1785  
                         stream_AS.nextNode()
 1786  
                         , root_1);
 1787  
 
 1788  250
                         adaptor.addChild(root_1, stream_expression.nextTree());
 1789  
 
 1790  250
                         adaptor.addChild(root_1, stream_var.nextTree());
 1791  
 
 1792  250
                         adaptor.addChild(root_0, root_1);
 1793  
                         }
 1794  
 
 1795  
                     }
 1796  
 
 1797  
 
 1798  250
                     retval.tree = root_0;
 1799  
 
 1800  
                     }
 1801  
                     break;
 1802  
 
 1803  
             }
 1804  1666
             retval.stop = input.LT(-1);
 1805  
 
 1806  
 
 1807  1666
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 1808  1666
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 1809  
 
 1810  
         }
 1811  0
         catch (RecognitionException re) {
 1812  0
             reportError(re);
 1813  0
             recover(input,re);
 1814  0
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 1815  
 
 1816  
         }
 1817  
 
 1818  0
         finally {
 1819  
                 // do for sure before leaving
 1820  1666
         }
 1821  1666
         return retval;
 1822  
     }
 1823  
     // $ANTLR end "selectVariables"
 1824  
 
 1825  
 
 1826  70
     public static class constructQuery_return extends ParserRuleReturnScope {
 1827  
         Object tree;
 1828  70
         public Object getTree() { return tree; }
 1829  
     };
 1830  
 
 1831  
 
 1832  
     // $ANTLR start "constructQuery"
 1833  
     // com\\googlecode\\sparkleg\\Sparql.g:112:1: constructQuery : ( CONSTRUCT constructTemplate ( datasetClause )* whereClause solutionModifier -> ^( CONSTRUCT constructTemplate ( datasetClause )* ( whereClause )* ( solutionModifier )* ) | CONSTRUCT ( datasetClause )* WHERE groupGraphPattern solutionModifier -> ^( CONSTRUCT ( datasetClause )* ^( WHERE_CLAUSE ( groupGraphPattern )* ) ( solutionModifier )* ) );
 1834  
     public final SparqlParser.constructQuery_return constructQuery() throws RecognitionException {
 1835  70
         SparqlParser.constructQuery_return retval = new SparqlParser.constructQuery_return();
 1836  70
         retval.start = input.LT(1);
 1837  
 
 1838  
 
 1839  70
         Object root_0 = null;
 1840  
 
 1841  70
         Token CONSTRUCT39=null;
 1842  70
         Token CONSTRUCT44=null;
 1843  70
         Token WHERE46=null;
 1844  70
         SparqlParser.constructTemplate_return constructTemplate40 =null;
 1845  
 
 1846  70
         SparqlParser.datasetClause_return datasetClause41 =null;
 1847  
 
 1848  70
         SparqlParser.whereClause_return whereClause42 =null;
 1849  
 
 1850  70
         SparqlParser.solutionModifier_return solutionModifier43 =null;
 1851  
 
 1852  70
         SparqlParser.datasetClause_return datasetClause45 =null;
 1853  
 
 1854  70
         SparqlParser.groupGraphPattern_return groupGraphPattern47 =null;
 1855  
 
 1856  70
         SparqlParser.solutionModifier_return solutionModifier48 =null;
 1857  
 
 1858  
 
 1859  70
         Object CONSTRUCT39_tree=null;
 1860  70
         Object CONSTRUCT44_tree=null;
 1861  70
         Object WHERE46_tree=null;
 1862  70
         RewriteRuleTokenStream stream_WHERE=new RewriteRuleTokenStream(adaptor,"token WHERE");
 1863  70
         RewriteRuleTokenStream stream_CONSTRUCT=new RewriteRuleTokenStream(adaptor,"token CONSTRUCT");
 1864  70
         RewriteRuleSubtreeStream stream_whereClause=new RewriteRuleSubtreeStream(adaptor,"rule whereClause");
 1865  70
         RewriteRuleSubtreeStream stream_datasetClause=new RewriteRuleSubtreeStream(adaptor,"rule datasetClause");
 1866  70
         RewriteRuleSubtreeStream stream_groupGraphPattern=new RewriteRuleSubtreeStream(adaptor,"rule groupGraphPattern");
 1867  70
         RewriteRuleSubtreeStream stream_solutionModifier=new RewriteRuleSubtreeStream(adaptor,"rule solutionModifier");
 1868  70
         RewriteRuleSubtreeStream stream_constructTemplate=new RewriteRuleSubtreeStream(adaptor,"rule constructTemplate");
 1869  
         try {
 1870  
             // com\\googlecode\\sparkleg\\Sparql.g:113:5: ( CONSTRUCT constructTemplate ( datasetClause )* whereClause solutionModifier -> ^( CONSTRUCT constructTemplate ( datasetClause )* ( whereClause )* ( solutionModifier )* ) | CONSTRUCT ( datasetClause )* WHERE groupGraphPattern solutionModifier -> ^( CONSTRUCT ( datasetClause )* ^( WHERE_CLAUSE ( groupGraphPattern )* ) ( solutionModifier )* ) )
 1871  70
             int alt14=2;
 1872  70
             switch ( input.LA(1) ) {
 1873  
             case CONSTRUCT:
 1874  
                 {
 1875  70
                 switch ( input.LA(2) ) {
 1876  
                 case OPEN_CURLY_BRACE:
 1877  
                     {
 1878  54
                     alt14=1;
 1879  
                     }
 1880  54
                     break;
 1881  
                 case FROM:
 1882  
                 case WHERE:
 1883  
                     {
 1884  16
                     alt14=2;
 1885  
                     }
 1886  16
                     break;
 1887  
                 default:
 1888  0
                     NoViableAltException nvae =
 1889  
                         new NoViableAltException("", 14, 1, input);
 1890  
 
 1891  0
                     throw nvae;
 1892  
 
 1893  
                 }
 1894  
 
 1895  
                 }
 1896  70
                 break;
 1897  
             default:
 1898  0
                 NoViableAltException nvae =
 1899  
                     new NoViableAltException("", 14, 0, input);
 1900  
 
 1901  0
                 throw nvae;
 1902  
 
 1903  
             }
 1904  
 
 1905  70
             switch (alt14) {
 1906  
                 case 1 :
 1907  
                     // com\\googlecode\\sparkleg\\Sparql.g:113:7: CONSTRUCT constructTemplate ( datasetClause )* whereClause solutionModifier
 1908  
                     {
 1909  54
                     CONSTRUCT39=(Token)match(input,CONSTRUCT,FOLLOW_CONSTRUCT_in_constructQuery558);  
 1910  54
                     stream_CONSTRUCT.add(CONSTRUCT39);
 1911  
 
 1912  
 
 1913  54
                     pushFollow(FOLLOW_constructTemplate_in_constructQuery560);
 1914  54
                     constructTemplate40=constructTemplate();
 1915  
 
 1916  54
                     state._fsp--;
 1917  
 
 1918  54
                     stream_constructTemplate.add(constructTemplate40.getTree());
 1919  
 
 1920  
                     // com\\googlecode\\sparkleg\\Sparql.g:113:35: ( datasetClause )*
 1921  
                     loop12:
 1922  
                     do {
 1923  54
                         int alt12=2;
 1924  54
                         switch ( input.LA(1) ) {
 1925  
                         case FROM:
 1926  
                             {
 1927  0
                             alt12=1;
 1928  
                             }
 1929  
                             break;
 1930  
 
 1931  
                         }
 1932  
 
 1933  54
                         switch (alt12) {
 1934  
                             case 1 :
 1935  
                                 // com\\googlecode\\sparkleg\\Sparql.g:113:35: datasetClause
 1936  
                                 {
 1937  0
                                 pushFollow(FOLLOW_datasetClause_in_constructQuery562);
 1938  0
                                 datasetClause41=datasetClause();
 1939  
 
 1940  0
                                 state._fsp--;
 1941  
 
 1942  0
                                 stream_datasetClause.add(datasetClause41.getTree());
 1943  
 
 1944  
                                 }
 1945  0
                                 break;
 1946  
 
 1947  
                             default :
 1948  54
                                 break loop12;
 1949  
                         }
 1950  0
                     } while (true);
 1951  
 
 1952  
 
 1953  54
                     pushFollow(FOLLOW_whereClause_in_constructQuery565);
 1954  54
                     whereClause42=whereClause();
 1955  
 
 1956  54
                     state._fsp--;
 1957  
 
 1958  54
                     stream_whereClause.add(whereClause42.getTree());
 1959  
 
 1960  54
                     pushFollow(FOLLOW_solutionModifier_in_constructQuery567);
 1961  54
                     solutionModifier43=solutionModifier();
 1962  
 
 1963  54
                     state._fsp--;
 1964  
 
 1965  54
                     stream_solutionModifier.add(solutionModifier43.getTree());
 1966  
 
 1967  
                     // AST REWRITE
 1968  
                     // elements: constructTemplate, whereClause, solutionModifier, datasetClause, CONSTRUCT
 1969  
                     // token labels: 
 1970  
                     // rule labels: retval
 1971  
                     // token list labels: 
 1972  
                     // rule list labels: 
 1973  
                     // wildcard labels: 
 1974  54
                     retval.tree = root_0;
 1975  54
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 1976  
 
 1977  54
                     root_0 = (Object)adaptor.nil();
 1978  
                     // 113:79: -> ^( CONSTRUCT constructTemplate ( datasetClause )* ( whereClause )* ( solutionModifier )* )
 1979  
                     {
 1980  
                         // com\\googlecode\\sparkleg\\Sparql.g:113:82: ^( CONSTRUCT constructTemplate ( datasetClause )* ( whereClause )* ( solutionModifier )* )
 1981  
                         {
 1982  54
                         Object root_1 = (Object)adaptor.nil();
 1983  54
                         root_1 = (Object)adaptor.becomeRoot(
 1984  
                         stream_CONSTRUCT.nextNode()
 1985  
                         , root_1);
 1986  
 
 1987  54
                         adaptor.addChild(root_1, stream_constructTemplate.nextTree());
 1988  
 
 1989  
                         // com\\googlecode\\sparkleg\\Sparql.g:113:112: ( datasetClause )*
 1990  54
                         while ( stream_datasetClause.hasNext() ) {
 1991  0
                             adaptor.addChild(root_1, stream_datasetClause.nextTree());
 1992  
 
 1993  
                         }
 1994  54
                         stream_datasetClause.reset();
 1995  
 
 1996  
                         // com\\googlecode\\sparkleg\\Sparql.g:113:127: ( whereClause )*
 1997  108
                         while ( stream_whereClause.hasNext() ) {
 1998  54
                             adaptor.addChild(root_1, stream_whereClause.nextTree());
 1999  
 
 2000  
                         }
 2001  54
                         stream_whereClause.reset();
 2002  
 
 2003  
                         // com\\googlecode\\sparkleg\\Sparql.g:113:140: ( solutionModifier )*
 2004  60
                         while ( stream_solutionModifier.hasNext() ) {
 2005  6
                             adaptor.addChild(root_1, stream_solutionModifier.nextTree());
 2006  
 
 2007  
                         }
 2008  54
                         stream_solutionModifier.reset();
 2009  
 
 2010  54
                         adaptor.addChild(root_0, root_1);
 2011  
                         }
 2012  
 
 2013  
                     }
 2014  
 
 2015  
 
 2016  54
                     retval.tree = root_0;
 2017  
 
 2018  
                     }
 2019  54
                     break;
 2020  
                 case 2 :
 2021  
                     // com\\googlecode\\sparkleg\\Sparql.g:114:7: CONSTRUCT ( datasetClause )* WHERE groupGraphPattern solutionModifier
 2022  
                     {
 2023  16
                     CONSTRUCT44=(Token)match(input,CONSTRUCT,FOLLOW_CONSTRUCT_in_constructQuery592);  
 2024  16
                     stream_CONSTRUCT.add(CONSTRUCT44);
 2025  
 
 2026  
 
 2027  
                     // com\\googlecode\\sparkleg\\Sparql.g:114:17: ( datasetClause )*
 2028  
                     loop13:
 2029  
                     do {
 2030  18
                         int alt13=2;
 2031  18
                         switch ( input.LA(1) ) {
 2032  
                         case FROM:
 2033  
                             {
 2034  2
                             alt13=1;
 2035  
                             }
 2036  
                             break;
 2037  
 
 2038  
                         }
 2039  
 
 2040  18
                         switch (alt13) {
 2041  
                             case 1 :
 2042  
                                 // com\\googlecode\\sparkleg\\Sparql.g:114:17: datasetClause
 2043  
                                 {
 2044  2
                                 pushFollow(FOLLOW_datasetClause_in_constructQuery594);
 2045  2
                                 datasetClause45=datasetClause();
 2046  
 
 2047  2
                                 state._fsp--;
 2048  
 
 2049  2
                                 stream_datasetClause.add(datasetClause45.getTree());
 2050  
 
 2051  
                                 }
 2052  2
                                 break;
 2053  
 
 2054  
                             default :
 2055  16
                                 break loop13;
 2056  
                         }
 2057  2
                     } while (true);
 2058  
 
 2059  
 
 2060  16
                     WHERE46=(Token)match(input,WHERE,FOLLOW_WHERE_in_constructQuery597);  
 2061  16
                     stream_WHERE.add(WHERE46);
 2062  
 
 2063  
 
 2064  16
                     pushFollow(FOLLOW_groupGraphPattern_in_constructQuery599);
 2065  16
                     groupGraphPattern47=groupGraphPattern();
 2066  
 
 2067  16
                     state._fsp--;
 2068  
 
 2069  16
                     stream_groupGraphPattern.add(groupGraphPattern47.getTree());
 2070  
 
 2071  16
                     pushFollow(FOLLOW_solutionModifier_in_constructQuery601);
 2072  16
                     solutionModifier48=solutionModifier();
 2073  
 
 2074  16
                     state._fsp--;
 2075  
 
 2076  16
                     stream_solutionModifier.add(solutionModifier48.getTree());
 2077  
 
 2078  
                     // AST REWRITE
 2079  
                     // elements: groupGraphPattern, CONSTRUCT, datasetClause, solutionModifier
 2080  
                     // token labels: 
 2081  
                     // rule labels: retval
 2082  
                     // token list labels: 
 2083  
                     // rule list labels: 
 2084  
                     // wildcard labels: 
 2085  16
                     retval.tree = root_0;
 2086  16
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 2087  
 
 2088  16
                     root_0 = (Object)adaptor.nil();
 2089  
                     // 114:73: -> ^( CONSTRUCT ( datasetClause )* ^( WHERE_CLAUSE ( groupGraphPattern )* ) ( solutionModifier )* )
 2090  
                     {
 2091  
                         // com\\googlecode\\sparkleg\\Sparql.g:114:76: ^( CONSTRUCT ( datasetClause )* ^( WHERE_CLAUSE ( groupGraphPattern )* ) ( solutionModifier )* )
 2092  
                         {
 2093  16
                         Object root_1 = (Object)adaptor.nil();
 2094  16
                         root_1 = (Object)adaptor.becomeRoot(
 2095  
                         stream_CONSTRUCT.nextNode()
 2096  
                         , root_1);
 2097  
 
 2098  
                         // com\\googlecode\\sparkleg\\Sparql.g:114:88: ( datasetClause )*
 2099  18
                         while ( stream_datasetClause.hasNext() ) {
 2100  2
                             adaptor.addChild(root_1, stream_datasetClause.nextTree());
 2101  
 
 2102  
                         }
 2103  16
                         stream_datasetClause.reset();
 2104  
 
 2105  
                         // com\\googlecode\\sparkleg\\Sparql.g:114:103: ^( WHERE_CLAUSE ( groupGraphPattern )* )
 2106  
                         {
 2107  16
                         Object root_2 = (Object)adaptor.nil();
 2108  16
                         root_2 = (Object)adaptor.becomeRoot(
 2109  
                         (Object)adaptor.create(WHERE_CLAUSE, "WHERE_CLAUSE")
 2110  
                         , root_2);
 2111  
 
 2112  
                         // com\\googlecode\\sparkleg\\Sparql.g:114:118: ( groupGraphPattern )*
 2113  32
                         while ( stream_groupGraphPattern.hasNext() ) {
 2114  16
                             adaptor.addChild(root_2, stream_groupGraphPattern.nextTree());
 2115  
 
 2116  
                         }
 2117  16
                         stream_groupGraphPattern.reset();
 2118  
 
 2119  16
                         adaptor.addChild(root_1, root_2);
 2120  
                         }
 2121  
 
 2122  
                         // com\\googlecode\\sparkleg\\Sparql.g:114:138: ( solutionModifier )*
 2123  16
                         while ( stream_solutionModifier.hasNext() ) {
 2124  0
                             adaptor.addChild(root_1, stream_solutionModifier.nextTree());
 2125  
 
 2126  
                         }
 2127  16
                         stream_solutionModifier.reset();
 2128  
 
 2129  16
                         adaptor.addChild(root_0, root_1);
 2130  
                         }
 2131  
 
 2132  
                     }
 2133  
 
 2134  
 
 2135  16
                     retval.tree = root_0;
 2136  
 
 2137  
                     }
 2138  
                     break;
 2139  
 
 2140  
             }
 2141  70
             retval.stop = input.LT(-1);
 2142  
 
 2143  
 
 2144  70
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 2145  70
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 2146  
 
 2147  
         }
 2148  0
         catch (RecognitionException re) {
 2149  0
             reportError(re);
 2150  0
             recover(input,re);
 2151  0
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 2152  
 
 2153  
         }
 2154  
 
 2155  0
         finally {
 2156  
                 // do for sure before leaving
 2157  70
         }
 2158  70
         return retval;
 2159  
     }
 2160  
     // $ANTLR end "constructQuery"
 2161  
 
 2162  
 
 2163  28
     public static class describeQuery_return extends ParserRuleReturnScope {
 2164  
         Object tree;
 2165  28
         public Object getTree() { return tree; }
 2166  
     };
 2167  
 
 2168  
 
 2169  
     // $ANTLR start "describeQuery"
 2170  
     // com\\googlecode\\sparkleg\\Sparql.g:117:1: describeQuery : DESCRIBE ( (v+= varOrIRIref )+ | ASTERISK ) ( datasetClause )* ( whereClause )? solutionModifier -> ^( DESCRIBE ( $v)* ( ASTERISK )* ( datasetClause )* ( whereClause )? ( solutionModifier )* ) ;
 2171  
     public final SparqlParser.describeQuery_return describeQuery() throws RecognitionException {
 2172  28
         SparqlParser.describeQuery_return retval = new SparqlParser.describeQuery_return();
 2173  28
         retval.start = input.LT(1);
 2174  
 
 2175  
 
 2176  28
         Object root_0 = null;
 2177  
 
 2178  28
         Token DESCRIBE49=null;
 2179  28
         Token ASTERISK50=null;
 2180  28
         List list_v=null;
 2181  28
         SparqlParser.datasetClause_return datasetClause51 =null;
 2182  
 
 2183  28
         SparqlParser.whereClause_return whereClause52 =null;
 2184  
 
 2185  28
         SparqlParser.solutionModifier_return solutionModifier53 =null;
 2186  
 
 2187  28
         RuleReturnScope v = null;
 2188  28
         Object DESCRIBE49_tree=null;
 2189  28
         Object ASTERISK50_tree=null;
 2190  28
         RewriteRuleTokenStream stream_ASTERISK=new RewriteRuleTokenStream(adaptor,"token ASTERISK");
 2191  28
         RewriteRuleTokenStream stream_DESCRIBE=new RewriteRuleTokenStream(adaptor,"token DESCRIBE");
 2192  28
         RewriteRuleSubtreeStream stream_varOrIRIref=new RewriteRuleSubtreeStream(adaptor,"rule varOrIRIref");
 2193  28
         RewriteRuleSubtreeStream stream_whereClause=new RewriteRuleSubtreeStream(adaptor,"rule whereClause");
 2194  28
         RewriteRuleSubtreeStream stream_datasetClause=new RewriteRuleSubtreeStream(adaptor,"rule datasetClause");
 2195  28
         RewriteRuleSubtreeStream stream_solutionModifier=new RewriteRuleSubtreeStream(adaptor,"rule solutionModifier");
 2196  
         try {
 2197  
             // com\\googlecode\\sparkleg\\Sparql.g:118:5: ( DESCRIBE ( (v+= varOrIRIref )+ | ASTERISK ) ( datasetClause )* ( whereClause )? solutionModifier -> ^( DESCRIBE ( $v)* ( ASTERISK )* ( datasetClause )* ( whereClause )? ( solutionModifier )* ) )
 2198  
             // com\\googlecode\\sparkleg\\Sparql.g:118:7: DESCRIBE ( (v+= varOrIRIref )+ | ASTERISK ) ( datasetClause )* ( whereClause )? solutionModifier
 2199  
             {
 2200  28
             DESCRIBE49=(Token)match(input,DESCRIBE,FOLLOW_DESCRIBE_in_describeQuery637);  
 2201  28
             stream_DESCRIBE.add(DESCRIBE49);
 2202  
 
 2203  
 
 2204  
             // com\\googlecode\\sparkleg\\Sparql.g:118:16: ( (v+= varOrIRIref )+ | ASTERISK )
 2205  28
             int alt16=2;
 2206  28
             switch ( input.LA(1) ) {
 2207  
             case IRI_REF:
 2208  
             case PNAME_LN:
 2209  
             case PNAME_NS:
 2210  
             case VAR1:
 2211  
             case VAR2:
 2212  
                 {
 2213  28
                 alt16=1;
 2214  
                 }
 2215  28
                 break;
 2216  
             case ASTERISK:
 2217  
                 {
 2218  0
                 alt16=2;
 2219  
                 }
 2220  0
                 break;
 2221  
             default:
 2222  0
                 NoViableAltException nvae =
 2223  
                     new NoViableAltException("", 16, 0, input);
 2224  
 
 2225  0
                 throw nvae;
 2226  
 
 2227  
             }
 2228  
 
 2229  28
             switch (alt16) {
 2230  
                 case 1 :
 2231  
                     // com\\googlecode\\sparkleg\\Sparql.g:118:17: (v+= varOrIRIref )+
 2232  
                     {
 2233  
                     // com\\googlecode\\sparkleg\\Sparql.g:118:17: (v+= varOrIRIref )+
 2234  28
                     int cnt15=0;
 2235  
                     loop15:
 2236  
                     do {
 2237  70
                         int alt15=2;
 2238  70
                         switch ( input.LA(1) ) {
 2239  
                         case IRI_REF:
 2240  
                         case PNAME_LN:
 2241  
                         case PNAME_NS:
 2242  
                         case VAR1:
 2243  
                         case VAR2:
 2244  
                             {
 2245  42
                             alt15=1;
 2246  
                             }
 2247  
                             break;
 2248  
 
 2249  
                         }
 2250  
 
 2251  70
                         switch (alt15) {
 2252  
                             case 1 :
 2253  
                                 // com\\googlecode\\sparkleg\\Sparql.g:118:18: v+= varOrIRIref
 2254  
                                 {
 2255  42
                                 pushFollow(FOLLOW_varOrIRIref_in_describeQuery643);
 2256  42
                                 v=varOrIRIref();
 2257  
 
 2258  42
                                 state._fsp--;
 2259  
 
 2260  42
                                 stream_varOrIRIref.add(v.getTree());
 2261  42
                                 if (list_v==null) list_v=new ArrayList();
 2262  42
                                 list_v.add(v.getTree());
 2263  
 
 2264  
 
 2265  
                                 }
 2266  42
                                 break;
 2267  
 
 2268  
                             default :
 2269  28
                                 if ( cnt15 >= 1 ) break loop15;
 2270  0
                                 EarlyExitException eee =
 2271  
                                     new EarlyExitException(15, input);
 2272  0
                                 throw eee;
 2273  
                         }
 2274  42
                         cnt15++;
 2275  42
                     } while (true);
 2276  
 
 2277  
 
 2278  
                     }
 2279  28
                     break;
 2280  
                 case 2 :
 2281  
                     // com\\googlecode\\sparkleg\\Sparql.g:118:37: ASTERISK
 2282  
                     {
 2283  0
                     ASTERISK50=(Token)match(input,ASTERISK,FOLLOW_ASTERISK_in_describeQuery649);  
 2284  0
                     stream_ASTERISK.add(ASTERISK50);
 2285  
 
 2286  
 
 2287  
                     }
 2288  
                     break;
 2289  
 
 2290  
             }
 2291  
 
 2292  
 
 2293  
             // com\\googlecode\\sparkleg\\Sparql.g:118:47: ( datasetClause )*
 2294  
             loop17:
 2295  
             do {
 2296  28
                 int alt17=2;
 2297  28
                 switch ( input.LA(1) ) {
 2298  
                 case FROM:
 2299  
                     {
 2300  0
                     alt17=1;
 2301  
                     }
 2302  
                     break;
 2303  
 
 2304  
                 }
 2305  
 
 2306  28
                 switch (alt17) {
 2307  
                     case 1 :
 2308  
                         // com\\googlecode\\sparkleg\\Sparql.g:118:47: datasetClause
 2309  
                         {
 2310  0
                         pushFollow(FOLLOW_datasetClause_in_describeQuery652);
 2311  0
                         datasetClause51=datasetClause();
 2312  
 
 2313  0
                         state._fsp--;
 2314  
 
 2315  0
                         stream_datasetClause.add(datasetClause51.getTree());
 2316  
 
 2317  
                         }
 2318  0
                         break;
 2319  
 
 2320  
                     default :
 2321  28
                         break loop17;
 2322  
                 }
 2323  0
             } while (true);
 2324  
 
 2325  
 
 2326  
             // com\\googlecode\\sparkleg\\Sparql.g:118:62: ( whereClause )?
 2327  28
             int alt18=2;
 2328  28
             switch ( input.LA(1) ) {
 2329  
                 case OPEN_CURLY_BRACE:
 2330  
                 case WHERE:
 2331  
                     {
 2332  22
                     alt18=1;
 2333  
                     }
 2334  
                     break;
 2335  
             }
 2336  
 
 2337  28
             switch (alt18) {
 2338  
                 case 1 :
 2339  
                     // com\\googlecode\\sparkleg\\Sparql.g:118:62: whereClause
 2340  
                     {
 2341  22
                     pushFollow(FOLLOW_whereClause_in_describeQuery655);
 2342  22
                     whereClause52=whereClause();
 2343  
 
 2344  22
                     state._fsp--;
 2345  
 
 2346  22
                     stream_whereClause.add(whereClause52.getTree());
 2347  
 
 2348  
                     }
 2349  
                     break;
 2350  
 
 2351  
             }
 2352  
 
 2353  
 
 2354  28
             pushFollow(FOLLOW_solutionModifier_in_describeQuery658);
 2355  28
             solutionModifier53=solutionModifier();
 2356  
 
 2357  28
             state._fsp--;
 2358  
 
 2359  28
             stream_solutionModifier.add(solutionModifier53.getTree());
 2360  
 
 2361  
             // AST REWRITE
 2362  
             // elements: v, solutionModifier, datasetClause, DESCRIBE, ASTERISK, whereClause
 2363  
             // token labels: 
 2364  
             // rule labels: retval
 2365  
             // token list labels: 
 2366  
             // rule list labels: v
 2367  
             // wildcard labels: 
 2368  28
             retval.tree = root_0;
 2369  28
             RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 2370  28
             RewriteRuleSubtreeStream stream_v=new RewriteRuleSubtreeStream(adaptor,"token v",list_v);
 2371  28
             root_0 = (Object)adaptor.nil();
 2372  
             // 118:92: -> ^( DESCRIBE ( $v)* ( ASTERISK )* ( datasetClause )* ( whereClause )? ( solutionModifier )* )
 2373  
             {
 2374  
                 // com\\googlecode\\sparkleg\\Sparql.g:118:95: ^( DESCRIBE ( $v)* ( ASTERISK )* ( datasetClause )* ( whereClause )? ( solutionModifier )* )
 2375  
                 {
 2376  28
                 Object root_1 = (Object)adaptor.nil();
 2377  28
                 root_1 = (Object)adaptor.becomeRoot(
 2378  
                 stream_DESCRIBE.nextNode()
 2379  
                 , root_1);
 2380  
 
 2381  
                 // com\\googlecode\\sparkleg\\Sparql.g:118:107: ( $v)*
 2382  70
                 while ( stream_v.hasNext() ) {
 2383  42
                     adaptor.addChild(root_1, stream_v.nextTree());
 2384  
 
 2385  
                 }
 2386  28
                 stream_v.reset();
 2387  
 
 2388  
                 // com\\googlecode\\sparkleg\\Sparql.g:118:110: ( ASTERISK )*
 2389  28
                 while ( stream_ASTERISK.hasNext() ) {
 2390  0
                     adaptor.addChild(root_1, 
 2391  
                     stream_ASTERISK.nextNode()
 2392  
                     );
 2393  
 
 2394  
                 }
 2395  28
                 stream_ASTERISK.reset();
 2396  
 
 2397  
                 // com\\googlecode\\sparkleg\\Sparql.g:118:120: ( datasetClause )*
 2398  28
                 while ( stream_datasetClause.hasNext() ) {
 2399  0
                     adaptor.addChild(root_1, stream_datasetClause.nextTree());
 2400  
 
 2401  
                 }
 2402  28
                 stream_datasetClause.reset();
 2403  
 
 2404  
                 // com\\googlecode\\sparkleg\\Sparql.g:118:135: ( whereClause )?
 2405  28
                 if ( stream_whereClause.hasNext() ) {
 2406  22
                     adaptor.addChild(root_1, stream_whereClause.nextTree());
 2407  
 
 2408  
                 }
 2409  28
                 stream_whereClause.reset();
 2410  
 
 2411  
                 // com\\googlecode\\sparkleg\\Sparql.g:118:148: ( solutionModifier )*
 2412  28
                 while ( stream_solutionModifier.hasNext() ) {
 2413  0
                     adaptor.addChild(root_1, stream_solutionModifier.nextTree());
 2414  
 
 2415  
                 }
 2416  28
                 stream_solutionModifier.reset();
 2417  
 
 2418  28
                 adaptor.addChild(root_0, root_1);
 2419  
                 }
 2420  
 
 2421  
             }
 2422  
 
 2423  
 
 2424  28
             retval.tree = root_0;
 2425  
 
 2426  
             }
 2427  
 
 2428  28
             retval.stop = input.LT(-1);
 2429  
 
 2430  
 
 2431  28
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 2432  28
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 2433  
 
 2434  
         }
 2435  0
         catch (RecognitionException re) {
 2436  0
             reportError(re);
 2437  0
             recover(input,re);
 2438  0
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 2439  
 
 2440  
         }
 2441  
 
 2442  0
         finally {
 2443  
                 // do for sure before leaving
 2444  28
         }
 2445  28
         return retval;
 2446  
     }
 2447  
     // $ANTLR end "describeQuery"
 2448  
 
 2449  
 
 2450  122
     public static class askQuery_return extends ParserRuleReturnScope {
 2451  
         Object tree;
 2452  122
         public Object getTree() { return tree; }
 2453  
     };
 2454  
 
 2455  
 
 2456  
     // $ANTLR start "askQuery"
 2457  
     // com\\googlecode\\sparkleg\\Sparql.g:121:1: askQuery : ASK ( datasetClause )* whereClause -> ^( ASK ( datasetClause )* whereClause ) ;
 2458  
     public final SparqlParser.askQuery_return askQuery() throws RecognitionException {
 2459  122
         SparqlParser.askQuery_return retval = new SparqlParser.askQuery_return();
 2460  122
         retval.start = input.LT(1);
 2461  
 
 2462  
 
 2463  122
         Object root_0 = null;
 2464  
 
 2465  122
         Token ASK54=null;
 2466  122
         SparqlParser.datasetClause_return datasetClause55 =null;
 2467  
 
 2468  122
         SparqlParser.whereClause_return whereClause56 =null;
 2469  
 
 2470  
 
 2471  122
         Object ASK54_tree=null;
 2472  122
         RewriteRuleTokenStream stream_ASK=new RewriteRuleTokenStream(adaptor,"token ASK");
 2473  122
         RewriteRuleSubtreeStream stream_whereClause=new RewriteRuleSubtreeStream(adaptor,"rule whereClause");
 2474  122
         RewriteRuleSubtreeStream stream_datasetClause=new RewriteRuleSubtreeStream(adaptor,"rule datasetClause");
 2475  
         try {
 2476  
             // com\\googlecode\\sparkleg\\Sparql.g:122:5: ( ASK ( datasetClause )* whereClause -> ^( ASK ( datasetClause )* whereClause ) )
 2477  
             // com\\googlecode\\sparkleg\\Sparql.g:122:7: ASK ( datasetClause )* whereClause
 2478  
             {
 2479  122
             ASK54=(Token)match(input,ASK,FOLLOW_ASK_in_askQuery697);  
 2480  122
             stream_ASK.add(ASK54);
 2481  
 
 2482  
 
 2483  
             // com\\googlecode\\sparkleg\\Sparql.g:122:11: ( datasetClause )*
 2484  
             loop19:
 2485  
             do {
 2486  122
                 int alt19=2;
 2487  122
                 switch ( input.LA(1) ) {
 2488  
                 case FROM:
 2489  
                     {
 2490  0
                     alt19=1;
 2491  
                     }
 2492  
                     break;
 2493  
 
 2494  
                 }
 2495  
 
 2496  122
                 switch (alt19) {
 2497  
                     case 1 :
 2498  
                         // com\\googlecode\\sparkleg\\Sparql.g:122:11: datasetClause
 2499  
                         {
 2500  0
                         pushFollow(FOLLOW_datasetClause_in_askQuery699);
 2501  0
                         datasetClause55=datasetClause();
 2502  
 
 2503  0
                         state._fsp--;
 2504  
 
 2505  0
                         stream_datasetClause.add(datasetClause55.getTree());
 2506  
 
 2507  
                         }
 2508  0
                         break;
 2509  
 
 2510  
                     default :
 2511  122
                         break loop19;
 2512  
                 }
 2513  0
             } while (true);
 2514  
 
 2515  
 
 2516  122
             pushFollow(FOLLOW_whereClause_in_askQuery702);
 2517  122
             whereClause56=whereClause();
 2518  
 
 2519  122
             state._fsp--;
 2520  
 
 2521  122
             stream_whereClause.add(whereClause56.getTree());
 2522  
 
 2523  
             // AST REWRITE
 2524  
             // elements: datasetClause, ASK, whereClause
 2525  
             // token labels: 
 2526  
             // rule labels: retval
 2527  
             // token list labels: 
 2528  
             // rule list labels: 
 2529  
             // wildcard labels: 
 2530  122
             retval.tree = root_0;
 2531  122
             RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 2532  
 
 2533  122
             root_0 = (Object)adaptor.nil();
 2534  
             // 122:38: -> ^( ASK ( datasetClause )* whereClause )
 2535  
             {
 2536  
                 // com\\googlecode\\sparkleg\\Sparql.g:122:41: ^( ASK ( datasetClause )* whereClause )
 2537  
                 {
 2538  122
                 Object root_1 = (Object)adaptor.nil();
 2539  122
                 root_1 = (Object)adaptor.becomeRoot(
 2540  
                 stream_ASK.nextNode()
 2541  
                 , root_1);
 2542  
 
 2543  
                 // com\\googlecode\\sparkleg\\Sparql.g:122:47: ( datasetClause )*
 2544  122
                 while ( stream_datasetClause.hasNext() ) {
 2545  0
                     adaptor.addChild(root_1, stream_datasetClause.nextTree());
 2546  
 
 2547  
                 }
 2548  122
                 stream_datasetClause.reset();
 2549  
 
 2550  122
                 adaptor.addChild(root_1, stream_whereClause.nextTree());
 2551  
 
 2552  122
                 adaptor.addChild(root_0, root_1);
 2553  
                 }
 2554  
 
 2555  
             }
 2556  
 
 2557  
 
 2558  122
             retval.tree = root_0;
 2559  
 
 2560  
             }
 2561  
 
 2562  122
             retval.stop = input.LT(-1);
 2563  
 
 2564  
 
 2565  122
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 2566  122
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 2567  
 
 2568  
         }
 2569  0
         catch (RecognitionException re) {
 2570  0
             reportError(re);
 2571  0
             recover(input,re);
 2572  0
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 2573  
 
 2574  
         }
 2575  
 
 2576  0
         finally {
 2577  
                 // do for sure before leaving
 2578  122
         }
 2579  122
         return retval;
 2580  
     }
 2581  
     // $ANTLR end "askQuery"
 2582  
 
 2583  
 
 2584  160
     public static class datasetClause_return extends ParserRuleReturnScope {
 2585  
         Object tree;
 2586  160
         public Object getTree() { return tree; }
 2587  
     };
 2588  
 
 2589  
 
 2590  
     // $ANTLR start "datasetClause"
 2591  
     // com\\googlecode\\sparkleg\\Sparql.g:125:1: datasetClause : FROM ( NAMED )? iriRef -> ^( FROM ( NAMED )? iriRef ) ;
 2592  
     public final SparqlParser.datasetClause_return datasetClause() throws RecognitionException {
 2593  160
         SparqlParser.datasetClause_return retval = new SparqlParser.datasetClause_return();
 2594  160
         retval.start = input.LT(1);
 2595  
 
 2596  
 
 2597  160
         Object root_0 = null;
 2598  
 
 2599  160
         Token FROM57=null;
 2600  160
         Token NAMED58=null;
 2601  160
         SparqlParser.iriRef_return iriRef59 =null;
 2602  
 
 2603  
 
 2604  160
         Object FROM57_tree=null;
 2605  160
         Object NAMED58_tree=null;
 2606  160
         RewriteRuleTokenStream stream_FROM=new RewriteRuleTokenStream(adaptor,"token FROM");
 2607  160
         RewriteRuleTokenStream stream_NAMED=new RewriteRuleTokenStream(adaptor,"token NAMED");
 2608  160
         RewriteRuleSubtreeStream stream_iriRef=new RewriteRuleSubtreeStream(adaptor,"rule iriRef");
 2609  
         try {
 2610  
             // com\\googlecode\\sparkleg\\Sparql.g:126:5: ( FROM ( NAMED )? iriRef -> ^( FROM ( NAMED )? iriRef ) )
 2611  
             // com\\googlecode\\sparkleg\\Sparql.g:126:7: FROM ( NAMED )? iriRef
 2612  
             {
 2613  160
             FROM57=(Token)match(input,FROM,FOLLOW_FROM_in_datasetClause730);  
 2614  160
             stream_FROM.add(FROM57);
 2615  
 
 2616  
 
 2617  
             // com\\googlecode\\sparkleg\\Sparql.g:126:12: ( NAMED )?
 2618  160
             int alt20=2;
 2619  160
             switch ( input.LA(1) ) {
 2620  
                 case NAMED:
 2621  
                     {
 2622  102
                     alt20=1;
 2623  
                     }
 2624  
                     break;
 2625  
             }
 2626  
 
 2627  160
             switch (alt20) {
 2628  
                 case 1 :
 2629  
                     // com\\googlecode\\sparkleg\\Sparql.g:126:12: NAMED
 2630  
                     {
 2631  102
                     NAMED58=(Token)match(input,NAMED,FOLLOW_NAMED_in_datasetClause732);  
 2632  102
                     stream_NAMED.add(NAMED58);
 2633  
 
 2634  
 
 2635  
                     }
 2636  
                     break;
 2637  
 
 2638  
             }
 2639  
 
 2640  
 
 2641  160
             pushFollow(FOLLOW_iriRef_in_datasetClause735);
 2642  160
             iriRef59=iriRef();
 2643  
 
 2644  160
             state._fsp--;
 2645  
 
 2646  160
             stream_iriRef.add(iriRef59.getTree());
 2647  
 
 2648  
             // AST REWRITE
 2649  
             // elements: NAMED, FROM, iriRef
 2650  
             // token labels: 
 2651  
             // rule labels: retval
 2652  
             // token list labels: 
 2653  
             // rule list labels: 
 2654  
             // wildcard labels: 
 2655  160
             retval.tree = root_0;
 2656  160
             RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 2657  
 
 2658  160
             root_0 = (Object)adaptor.nil();
 2659  
             // 126:26: -> ^( FROM ( NAMED )? iriRef )
 2660  
             {
 2661  
                 // com\\googlecode\\sparkleg\\Sparql.g:126:29: ^( FROM ( NAMED )? iriRef )
 2662  
                 {
 2663  160
                 Object root_1 = (Object)adaptor.nil();
 2664  160
                 root_1 = (Object)adaptor.becomeRoot(
 2665  
                 stream_FROM.nextNode()
 2666  
                 , root_1);
 2667  
 
 2668  
                 // com\\googlecode\\sparkleg\\Sparql.g:126:36: ( NAMED )?
 2669  160
                 if ( stream_NAMED.hasNext() ) {
 2670  102
                     adaptor.addChild(root_1, 
 2671  
                     stream_NAMED.nextNode()
 2672  
                     );
 2673  
 
 2674  
                 }
 2675  160
                 stream_NAMED.reset();
 2676  
 
 2677  160
                 adaptor.addChild(root_1, stream_iriRef.nextTree());
 2678  
 
 2679  160
                 adaptor.addChild(root_0, root_1);
 2680  
                 }
 2681  
 
 2682  
             }
 2683  
 
 2684  
 
 2685  160
             retval.tree = root_0;
 2686  
 
 2687  
             }
 2688  
 
 2689  160
             retval.stop = input.LT(-1);
 2690  
 
 2691  
 
 2692  160
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 2693  160
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 2694  
 
 2695  
         }
 2696  0
         catch (RecognitionException re) {
 2697  0
             reportError(re);
 2698  0
             recover(input,re);
 2699  0
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 2700  
 
 2701  
         }
 2702  
 
 2703  0
         finally {
 2704  
                 // do for sure before leaving
 2705  160
         }
 2706  160
         return retval;
 2707  
     }
 2708  
     // $ANTLR end "datasetClause"
 2709  
 
 2710  
 
 2711  1798
     public static class whereClause_return extends ParserRuleReturnScope {
 2712  
         Object tree;
 2713  1798
         public Object getTree() { return tree; }
 2714  
     };
 2715  
 
 2716  
 
 2717  
     // $ANTLR start "whereClause"
 2718  
     // com\\googlecode\\sparkleg\\Sparql.g:129:1: whereClause : ( WHERE )? groupGraphPattern -> ^( WHERE_CLAUSE groupGraphPattern ) ;
 2719  
     public final SparqlParser.whereClause_return whereClause() throws RecognitionException {
 2720  1798
         SparqlParser.whereClause_return retval = new SparqlParser.whereClause_return();
 2721  1798
         retval.start = input.LT(1);
 2722  
 
 2723  
 
 2724  1798
         Object root_0 = null;
 2725  
 
 2726  1798
         Token WHERE60=null;
 2727  1798
         SparqlParser.groupGraphPattern_return groupGraphPattern61 =null;
 2728  
 
 2729  
 
 2730  1798
         Object WHERE60_tree=null;
 2731  1798
         RewriteRuleTokenStream stream_WHERE=new RewriteRuleTokenStream(adaptor,"token WHERE");
 2732  1798
         RewriteRuleSubtreeStream stream_groupGraphPattern=new RewriteRuleSubtreeStream(adaptor,"rule groupGraphPattern");
 2733  
         try {
 2734  
             // com\\googlecode\\sparkleg\\Sparql.g:130:5: ( ( WHERE )? groupGraphPattern -> ^( WHERE_CLAUSE groupGraphPattern ) )
 2735  
             // com\\googlecode\\sparkleg\\Sparql.g:130:7: ( WHERE )? groupGraphPattern
 2736  
             {
 2737  
             // com\\googlecode\\sparkleg\\Sparql.g:130:7: ( WHERE )?
 2738  1798
             int alt21=2;
 2739  1798
             switch ( input.LA(1) ) {
 2740  
                 case WHERE:
 2741  
                     {
 2742  1553
                     alt21=1;
 2743  
                     }
 2744  
                     break;
 2745  
             }
 2746  
 
 2747  1798
             switch (alt21) {
 2748  
                 case 1 :
 2749  
                     // com\\googlecode\\sparkleg\\Sparql.g:130:7: WHERE
 2750  
                     {
 2751  1553
                     WHERE60=(Token)match(input,WHERE,FOLLOW_WHERE_in_whereClause763);  
 2752  1553
                     stream_WHERE.add(WHERE60);
 2753  
 
 2754  
 
 2755  
                     }
 2756  
                     break;
 2757  
 
 2758  
             }
 2759  
 
 2760  
 
 2761  1798
             pushFollow(FOLLOW_groupGraphPattern_in_whereClause766);
 2762  1798
             groupGraphPattern61=groupGraphPattern();
 2763  
 
 2764  1798
             state._fsp--;
 2765  
 
 2766  1798
             stream_groupGraphPattern.add(groupGraphPattern61.getTree());
 2767  
 
 2768  
             // AST REWRITE
 2769  
             // elements: groupGraphPattern
 2770  
             // token labels: 
 2771  
             // rule labels: retval
 2772  
             // token list labels: 
 2773  
             // rule list labels: 
 2774  
             // wildcard labels: 
 2775  1798
             retval.tree = root_0;
 2776  1798
             RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 2777  
 
 2778  1798
             root_0 = (Object)adaptor.nil();
 2779  
             // 130:32: -> ^( WHERE_CLAUSE groupGraphPattern )
 2780  
             {
 2781  
                 // com\\googlecode\\sparkleg\\Sparql.g:130:35: ^( WHERE_CLAUSE groupGraphPattern )
 2782  
                 {
 2783  1798
                 Object root_1 = (Object)adaptor.nil();
 2784  1798
                 root_1 = (Object)adaptor.becomeRoot(
 2785  
                 (Object)adaptor.create(WHERE_CLAUSE, "WHERE_CLAUSE")
 2786  
                 , root_1);
 2787  
 
 2788  1798
                 adaptor.addChild(root_1, stream_groupGraphPattern.nextTree());
 2789  
 
 2790  1798
                 adaptor.addChild(root_0, root_1);
 2791  
                 }
 2792  
 
 2793  
             }
 2794  
 
 2795  
 
 2796  1798
             retval.tree = root_0;
 2797  
 
 2798  
             }
 2799  
 
 2800  1798
             retval.stop = input.LT(-1);
 2801  
 
 2802  
 
 2803  1798
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 2804  1798
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 2805  
 
 2806  
         }
 2807  0
         catch (RecognitionException re) {
 2808  0
             reportError(re);
 2809  0
             recover(input,re);
 2810  0
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 2811  
 
 2812  
         }
 2813  
 
 2814  0
         finally {
 2815  
                 // do for sure before leaving
 2816  1798
         }
 2817  1798
         return retval;
 2818  
     }
 2819  
     // $ANTLR end "whereClause"
 2820  
 
 2821  
 
 2822  1698
     public static class solutionModifier_return extends ParserRuleReturnScope {
 2823  
         Object tree;
 2824  1698
         public Object getTree() { return tree; }
 2825  
     };
 2826  
 
 2827  
 
 2828  
     // $ANTLR start "solutionModifier"
 2829  
     // com\\googlecode\\sparkleg\\Sparql.g:133:1: solutionModifier : ( groupClause )? ( havingClause )? ( orderClause )? ( limitOffsetClauses )? -> ( groupClause )* ( havingClause )* ( orderClause )* ( limitOffsetClauses )* ;
 2830  
     public final SparqlParser.solutionModifier_return solutionModifier() throws RecognitionException {
 2831  1698
         SparqlParser.solutionModifier_return retval = new SparqlParser.solutionModifier_return();
 2832  1698
         retval.start = input.LT(1);
 2833  
 
 2834  
 
 2835  1698
         Object root_0 = null;
 2836  
 
 2837  1698
         SparqlParser.groupClause_return groupClause62 =null;
 2838  
 
 2839  1698
         SparqlParser.havingClause_return havingClause63 =null;
 2840  
 
 2841  1698
         SparqlParser.orderClause_return orderClause64 =null;
 2842  
 
 2843  1698
         SparqlParser.limitOffsetClauses_return limitOffsetClauses65 =null;
 2844  
 
 2845  
 
 2846  1698
         RewriteRuleSubtreeStream stream_limitOffsetClauses=new RewriteRuleSubtreeStream(adaptor,"rule limitOffsetClauses");
 2847  1698
         RewriteRuleSubtreeStream stream_orderClause=new RewriteRuleSubtreeStream(adaptor,"rule orderClause");
 2848  1698
         RewriteRuleSubtreeStream stream_groupClause=new RewriteRuleSubtreeStream(adaptor,"rule groupClause");
 2849  1698
         RewriteRuleSubtreeStream stream_havingClause=new RewriteRuleSubtreeStream(adaptor,"rule havingClause");
 2850  
         try {
 2851  
             // com\\googlecode\\sparkleg\\Sparql.g:134:5: ( ( groupClause )? ( havingClause )? ( orderClause )? ( limitOffsetClauses )? -> ( groupClause )* ( havingClause )* ( orderClause )* ( limitOffsetClauses )* )
 2852  
             // com\\googlecode\\sparkleg\\Sparql.g:134:7: ( groupClause )? ( havingClause )? ( orderClause )? ( limitOffsetClauses )?
 2853  
             {
 2854  
             // com\\googlecode\\sparkleg\\Sparql.g:134:7: ( groupClause )?
 2855  1698
             int alt22=2;
 2856  1698
             switch ( input.LA(1) ) {
 2857  
                 case GROUP:
 2858  
                     {
 2859  66
                     alt22=1;
 2860  
                     }
 2861  
                     break;
 2862  
             }
 2863  
 
 2864  1698
             switch (alt22) {
 2865  
                 case 1 :
 2866  
                     // com\\googlecode\\sparkleg\\Sparql.g:134:7: groupClause
 2867  
                     {
 2868  66
                     pushFollow(FOLLOW_groupClause_in_solutionModifier791);
 2869  66
                     groupClause62=groupClause();
 2870  
 
 2871  66
                     state._fsp--;
 2872  
 
 2873  66
                     stream_groupClause.add(groupClause62.getTree());
 2874  
 
 2875  
                     }
 2876  
                     break;
 2877  
 
 2878  
             }
 2879  
 
 2880  
 
 2881  
             // com\\googlecode\\sparkleg\\Sparql.g:134:20: ( havingClause )?
 2882  1698
             int alt23=2;
 2883  1698
             switch ( input.LA(1) ) {
 2884  
                 case HAVING:
 2885  
                     {
 2886  16
                     alt23=1;
 2887  
                     }
 2888  
                     break;
 2889  
             }
 2890  
 
 2891  1698
             switch (alt23) {
 2892  
                 case 1 :
 2893  
                     // com\\googlecode\\sparkleg\\Sparql.g:134:20: havingClause
 2894  
                     {
 2895  16
                     pushFollow(FOLLOW_havingClause_in_solutionModifier794);
 2896  16
                     havingClause63=havingClause();
 2897  
 
 2898  16
                     state._fsp--;
 2899  
 
 2900  16
                     stream_havingClause.add(havingClause63.getTree());
 2901  
 
 2902  
                     }
 2903  
                     break;
 2904  
 
 2905  
             }
 2906  
 
 2907  
 
 2908  
             // com\\googlecode\\sparkleg\\Sparql.g:134:34: ( orderClause )?
 2909  1698
             int alt24=2;
 2910  1698
             switch ( input.LA(1) ) {
 2911  
                 case ORDER:
 2912  
                     {
 2913  134
                     alt24=1;
 2914  
                     }
 2915  
                     break;
 2916  
             }
 2917  
 
 2918  1698
             switch (alt24) {
 2919  
                 case 1 :
 2920  
                     // com\\googlecode\\sparkleg\\Sparql.g:134:34: orderClause
 2921  
                     {
 2922  134
                     pushFollow(FOLLOW_orderClause_in_solutionModifier797);
 2923  134
                     orderClause64=orderClause();
 2924  
 
 2925  134
                     state._fsp--;
 2926  
 
 2927  134
                     stream_orderClause.add(orderClause64.getTree());
 2928  
 
 2929  
                     }
 2930  
                     break;
 2931  
 
 2932  
             }
 2933  
 
 2934  
 
 2935  
             // com\\googlecode\\sparkleg\\Sparql.g:134:47: ( limitOffsetClauses )?
 2936  1698
             int alt25=2;
 2937  1698
             switch ( input.LA(1) ) {
 2938  
                 case LIMIT:
 2939  
                 case OFFSET:
 2940  
                     {
 2941  58
                     alt25=1;
 2942  
                     }
 2943  
                     break;
 2944  
             }
 2945  
 
 2946  1698
             switch (alt25) {
 2947  
                 case 1 :
 2948  
                     // com\\googlecode\\sparkleg\\Sparql.g:134:47: limitOffsetClauses
 2949  
                     {
 2950  58
                     pushFollow(FOLLOW_limitOffsetClauses_in_solutionModifier800);
 2951  58
                     limitOffsetClauses65=limitOffsetClauses();
 2952  
 
 2953  58
                     state._fsp--;
 2954  
 
 2955  58
                     stream_limitOffsetClauses.add(limitOffsetClauses65.getTree());
 2956  
 
 2957  
                     }
 2958  
                     break;
 2959  
 
 2960  
             }
 2961  
 
 2962  
 
 2963  
             // AST REWRITE
 2964  
             // elements: havingClause, orderClause, groupClause, limitOffsetClauses
 2965  
             // token labels: 
 2966  
             // rule labels: retval
 2967  
             // token list labels: 
 2968  
             // rule list labels: 
 2969  
             // wildcard labels: 
 2970  1698
             retval.tree = root_0;
 2971  1698
             RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 2972  
 
 2973  1698
             root_0 = (Object)adaptor.nil();
 2974  
             // 134:67: -> ( groupClause )* ( havingClause )* ( orderClause )* ( limitOffsetClauses )*
 2975  
             {
 2976  
                 // com\\googlecode\\sparkleg\\Sparql.g:134:70: ( groupClause )*
 2977  1764
                 while ( stream_groupClause.hasNext() ) {
 2978  66
                     adaptor.addChild(root_0, stream_groupClause.nextTree());
 2979  
 
 2980  
                 }
 2981  1698
                 stream_groupClause.reset();
 2982  
 
 2983  
                 // com\\googlecode\\sparkleg\\Sparql.g:134:83: ( havingClause )*
 2984  1714
                 while ( stream_havingClause.hasNext() ) {
 2985  16
                     adaptor.addChild(root_0, stream_havingClause.nextTree());
 2986  
 
 2987  
                 }
 2988  1698
                 stream_havingClause.reset();
 2989  
 
 2990  
                 // com\\googlecode\\sparkleg\\Sparql.g:134:97: ( orderClause )*
 2991  1832
                 while ( stream_orderClause.hasNext() ) {
 2992  134
                     adaptor.addChild(root_0, stream_orderClause.nextTree());
 2993  
 
 2994  
                 }
 2995  1698
                 stream_orderClause.reset();
 2996  
 
 2997  
                 // com\\googlecode\\sparkleg\\Sparql.g:134:110: ( limitOffsetClauses )*
 2998  1756
                 while ( stream_limitOffsetClauses.hasNext() ) {
 2999  58
                     adaptor.addChild(root_0, stream_limitOffsetClauses.nextTree());
 3000  
 
 3001  
                 }
 3002  1698
                 stream_limitOffsetClauses.reset();
 3003  
 
 3004  
             }
 3005  
 
 3006  
 
 3007  1698
             retval.tree = root_0;
 3008  
 
 3009  
             }
 3010  
 
 3011  1698
             retval.stop = input.LT(-1);
 3012  
 
 3013  
 
 3014  1698
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 3015  1698
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 3016  
 
 3017  
         }
 3018  0
         catch (RecognitionException re) {
 3019  0
             reportError(re);
 3020  0
             recover(input,re);
 3021  0
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 3022  
 
 3023  
         }
 3024  
 
 3025  0
         finally {
 3026  
                 // do for sure before leaving
 3027  1698
         }
 3028  1698
         return retval;
 3029  
     }
 3030  
     // $ANTLR end "solutionModifier"
 3031  
 
 3032  
 
 3033  66
     public static class groupClause_return extends ParserRuleReturnScope {
 3034  
         Object tree;
 3035  66
         public Object getTree() { return tree; }
 3036  
     };
 3037  
 
 3038  
 
 3039  
     // $ANTLR start "groupClause"
 3040  
     // com\\googlecode\\sparkleg\\Sparql.g:137:1: groupClause : GROUP BY ( groupCondition )+ -> ^( GROUP_BY ( groupCondition )+ ) ;
 3041  
     public final SparqlParser.groupClause_return groupClause() throws RecognitionException {
 3042  66
         SparqlParser.groupClause_return retval = new SparqlParser.groupClause_return();
 3043  66
         retval.start = input.LT(1);
 3044  
 
 3045  
 
 3046  66
         Object root_0 = null;
 3047  
 
 3048  66
         Token GROUP66=null;
 3049  66
         Token BY67=null;
 3050  66
         SparqlParser.groupCondition_return groupCondition68 =null;
 3051  
 
 3052  
 
 3053  66
         Object GROUP66_tree=null;
 3054  66
         Object BY67_tree=null;
 3055  66
         RewriteRuleTokenStream stream_GROUP=new RewriteRuleTokenStream(adaptor,"token GROUP");
 3056  66
         RewriteRuleTokenStream stream_BY=new RewriteRuleTokenStream(adaptor,"token BY");
 3057  66
         RewriteRuleSubtreeStream stream_groupCondition=new RewriteRuleSubtreeStream(adaptor,"rule groupCondition");
 3058  
         try {
 3059  
             // com\\googlecode\\sparkleg\\Sparql.g:138:5: ( GROUP BY ( groupCondition )+ -> ^( GROUP_BY ( groupCondition )+ ) )
 3060  
             // com\\googlecode\\sparkleg\\Sparql.g:138:7: GROUP BY ( groupCondition )+
 3061  
             {
 3062  66
             GROUP66=(Token)match(input,GROUP,FOLLOW_GROUP_in_groupClause832);  
 3063  66
             stream_GROUP.add(GROUP66);
 3064  
 
 3065  
 
 3066  66
             BY67=(Token)match(input,BY,FOLLOW_BY_in_groupClause834);  
 3067  66
             stream_BY.add(BY67);
 3068  
 
 3069  
 
 3070  
             // com\\googlecode\\sparkleg\\Sparql.g:138:16: ( groupCondition )+
 3071  66
             int cnt26=0;
 3072  
             loop26:
 3073  
             do {
 3074  136
                 int alt26=2;
 3075  136
                 switch ( input.LA(1) ) {
 3076  
                 case ABS:
 3077  
                 case BNODE:
 3078  
                 case BOUND:
 3079  
                 case CEIL:
 3080  
                 case COALESCE:
 3081  
                 case CONCAT:
 3082  
                 case CONTAINS:
 3083  
                 case DATATYPE:
 3084  
                 case DAY:
 3085  
                 case ENCODE_FOR_URI:
 3086  
                 case EXISTS:
 3087  
                 case FLOOR:
 3088  
                 case HOURS:
 3089  
                 case IF:
 3090  
                 case IRI:
 3091  
                 case IRI_REF:
 3092  
                 case ISBLANK:
 3093  
                 case ISIRI:
 3094  
                 case ISLITERAL:
 3095  
                 case ISNUMERIC:
 3096  
                 case ISURI:
 3097  
                 case LANG:
 3098  
                 case LANGMATCHES:
 3099  
                 case LCASE:
 3100  
                 case MD5:
 3101  
                 case MINUTES:
 3102  
                 case MONTH:
 3103  
                 case NOT:
 3104  
                 case NOW:
 3105  
                 case OPEN_BRACE:
 3106  
                 case PNAME_LN:
 3107  
                 case PNAME_NS:
 3108  
                 case RAND:
 3109  
                 case REGEX:
 3110  
                 case REPLACE:
 3111  
                 case ROUND:
 3112  
                 case SAMETERM:
 3113  
                 case SECONDS:
 3114  
                 case SHA1:
 3115  
                 case SHA224:
 3116  
                 case SHA256:
 3117  
                 case SHA384:
 3118  
                 case SHA512:
 3119  
                 case STR:
 3120  
                 case STRAFTER:
 3121  
                 case STRBEFORE:
 3122  
                 case STRDT:
 3123  
                 case STRENDS:
 3124  
                 case STRLANG:
 3125  
                 case STRLEN:
 3126  
                 case STRSTARTS:
 3127  
                 case SUBSTR:
 3128  
                 case TIMEZONE:
 3129  
                 case TZ:
 3130  
                 case UCASE:
 3131  
                 case URI:
 3132  
                 case VAR1:
 3133  
                 case VAR2:
 3134  
                 case YEAR:
 3135  
                     {
 3136  70
                     alt26=1;
 3137  
                     }
 3138  
                     break;
 3139  
 
 3140  
                 }
 3141  
 
 3142  136
                 switch (alt26) {
 3143  
                     case 1 :
 3144  
                         // com\\googlecode\\sparkleg\\Sparql.g:138:16: groupCondition
 3145  
                         {
 3146  70
                         pushFollow(FOLLOW_groupCondition_in_groupClause836);
 3147  70
                         groupCondition68=groupCondition();
 3148  
 
 3149  70
                         state._fsp--;
 3150  
 
 3151  70
                         stream_groupCondition.add(groupCondition68.getTree());
 3152  
 
 3153  
                         }
 3154  70
                         break;
 3155  
 
 3156  
                     default :
 3157  66
                         if ( cnt26 >= 1 ) break loop26;
 3158  0
                         EarlyExitException eee =
 3159  
                             new EarlyExitException(26, input);
 3160  0
                         throw eee;
 3161  
                 }
 3162  70
                 cnt26++;
 3163  70
             } while (true);
 3164  
 
 3165  
 
 3166  
             // AST REWRITE
 3167  
             // elements: groupCondition
 3168  
             // token labels: 
 3169  
             // rule labels: retval
 3170  
             // token list labels: 
 3171  
             // rule list labels: 
 3172  
             // wildcard labels: 
 3173  66
             retval.tree = root_0;
 3174  66
             RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 3175  
 
 3176  66
             root_0 = (Object)adaptor.nil();
 3177  
             // 138:32: -> ^( GROUP_BY ( groupCondition )+ )
 3178  
             {
 3179  
                 // com\\googlecode\\sparkleg\\Sparql.g:138:35: ^( GROUP_BY ( groupCondition )+ )
 3180  
                 {
 3181  66
                 Object root_1 = (Object)adaptor.nil();
 3182  66
                 root_1 = (Object)adaptor.becomeRoot(
 3183  
                 (Object)adaptor.create(GROUP_BY, "GROUP_BY")
 3184  
                 , root_1);
 3185  
 
 3186  66
                 if ( !(stream_groupCondition.hasNext()) ) {
 3187  0
                     throw new RewriteEarlyExitException();
 3188  
                 }
 3189  136
                 while ( stream_groupCondition.hasNext() ) {
 3190  70
                     adaptor.addChild(root_1, stream_groupCondition.nextTree());
 3191  
 
 3192  
                 }
 3193  66
                 stream_groupCondition.reset();
 3194  
 
 3195  66
                 adaptor.addChild(root_0, root_1);
 3196  
                 }
 3197  
 
 3198  
             }
 3199  
 
 3200  
 
 3201  66
             retval.tree = root_0;
 3202  
 
 3203  
             }
 3204  
 
 3205  66
             retval.stop = input.LT(-1);
 3206  
 
 3207  
 
 3208  66
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 3209  66
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 3210  
 
 3211  
         }
 3212  0
         catch (RecognitionException re) {
 3213  0
             reportError(re);
 3214  0
             recover(input,re);
 3215  0
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 3216  
 
 3217  
         }
 3218  
 
 3219  0
         finally {
 3220  
                 // do for sure before leaving
 3221  66
         }
 3222  66
         return retval;
 3223  
     }
 3224  
     // $ANTLR end "groupClause"
 3225  
 
 3226  
 
 3227  70
     public static class groupCondition_return extends ParserRuleReturnScope {
 3228  
         Object tree;
 3229  70
         public Object getTree() { return tree; }
 3230  
     };
 3231  
 
 3232  
 
 3233  
     // $ANTLR start "groupCondition"
 3234  
     // com\\googlecode\\sparkleg\\Sparql.g:141:1: groupCondition : ( builtInCall -> ^( GROUP_CONDITION builtInCall ) | functionCall -> ^( GROUP_CONDITION functionCall ) | OPEN_BRACE expression ( AS var )? CLOSE_BRACE -> ^( GROUP_CONDITION expression ( var )? ) | var -> ^( GROUP_CONDITION var ) );
 3235  
     public final SparqlParser.groupCondition_return groupCondition() throws RecognitionException {
 3236  70
         SparqlParser.groupCondition_return retval = new SparqlParser.groupCondition_return();
 3237  70
         retval.start = input.LT(1);
 3238  
 
 3239  
 
 3240  70
         Object root_0 = null;
 3241  
 
 3242  70
         Token OPEN_BRACE71=null;
 3243  70
         Token AS73=null;
 3244  70
         Token CLOSE_BRACE75=null;
 3245  70
         SparqlParser.builtInCall_return builtInCall69 =null;
 3246  
 
 3247  70
         SparqlParser.functionCall_return functionCall70 =null;
 3248  
 
 3249  70
         SparqlParser.expression_return expression72 =null;
 3250  
 
 3251  70
         SparqlParser.var_return var74 =null;
 3252  
 
 3253  70
         SparqlParser.var_return var76 =null;
 3254  
 
 3255  
 
 3256  70
         Object OPEN_BRACE71_tree=null;
 3257  70
         Object AS73_tree=null;
 3258  70
         Object CLOSE_BRACE75_tree=null;
 3259  70
         RewriteRuleTokenStream stream_AS=new RewriteRuleTokenStream(adaptor,"token AS");
 3260  70
         RewriteRuleTokenStream stream_CLOSE_BRACE=new RewriteRuleTokenStream(adaptor,"token CLOSE_BRACE");
 3261  70
         RewriteRuleTokenStream stream_OPEN_BRACE=new RewriteRuleTokenStream(adaptor,"token OPEN_BRACE");
 3262  70
         RewriteRuleSubtreeStream stream_expression=new RewriteRuleSubtreeStream(adaptor,"rule expression");
 3263  70
         RewriteRuleSubtreeStream stream_functionCall=new RewriteRuleSubtreeStream(adaptor,"rule functionCall");
 3264  70
         RewriteRuleSubtreeStream stream_var=new RewriteRuleSubtreeStream(adaptor,"rule var");
 3265  70
         RewriteRuleSubtreeStream stream_builtInCall=new RewriteRuleSubtreeStream(adaptor,"rule builtInCall");
 3266  
         try {
 3267  
             // com\\googlecode\\sparkleg\\Sparql.g:142:5: ( builtInCall -> ^( GROUP_CONDITION builtInCall ) | functionCall -> ^( GROUP_CONDITION functionCall ) | OPEN_BRACE expression ( AS var )? CLOSE_BRACE -> ^( GROUP_CONDITION expression ( var )? ) | var -> ^( GROUP_CONDITION var ) )
 3268  70
             int alt28=4;
 3269  70
             switch ( input.LA(1) ) {
 3270  
             case ABS:
 3271  
             case BNODE:
 3272  
             case BOUND:
 3273  
             case CEIL:
 3274  
             case COALESCE:
 3275  
             case CONCAT:
 3276  
             case CONTAINS:
 3277  
             case DATATYPE:
 3278  
             case DAY:
 3279  
             case ENCODE_FOR_URI:
 3280  
             case EXISTS:
 3281  
             case FLOOR:
 3282  
             case HOURS:
 3283  
             case IF:
 3284  
             case IRI:
 3285  
             case ISBLANK:
 3286  
             case ISIRI:
 3287  
             case ISLITERAL:
 3288  
             case ISNUMERIC:
 3289  
             case ISURI:
 3290  
             case LANG:
 3291  
             case LANGMATCHES:
 3292  
             case LCASE:
 3293  
             case MD5:
 3294  
             case MINUTES:
 3295  
             case MONTH:
 3296  
             case NOT:
 3297  
             case NOW:
 3298  
             case RAND:
 3299  
             case REGEX:
 3300  
             case REPLACE:
 3301  
             case ROUND:
 3302  
             case SAMETERM:
 3303  
             case SECONDS:
 3304  
             case SHA1:
 3305  
             case SHA224:
 3306  
             case SHA256:
 3307  
             case SHA384:
 3308  
             case SHA512:
 3309  
             case STR:
 3310  
             case STRAFTER:
 3311  
             case STRBEFORE:
 3312  
             case STRDT:
 3313  
             case STRENDS:
 3314  
             case STRLANG:
 3315  
             case STRLEN:
 3316  
             case STRSTARTS:
 3317  
             case SUBSTR:
 3318  
             case TIMEZONE:
 3319  
             case TZ:
 3320  
             case UCASE:
 3321  
             case URI:
 3322  
             case YEAR:
 3323  
                 {
 3324  0
                 alt28=1;
 3325  
                 }
 3326  0
                 break;
 3327  
             case IRI_REF:
 3328  
             case PNAME_LN:
 3329  
             case PNAME_NS:
 3330  
                 {
 3331  0
                 alt28=2;
 3332  
                 }
 3333  0
                 break;
 3334  
             case OPEN_BRACE:
 3335  
                 {
 3336  12
                 alt28=3;
 3337  
                 }
 3338  12
                 break;
 3339  
             case VAR1:
 3340  
             case VAR2:
 3341  
                 {
 3342  58
                 alt28=4;
 3343  
                 }
 3344  58
                 break;
 3345  
             default:
 3346  0
                 NoViableAltException nvae =
 3347  
                     new NoViableAltException("", 28, 0, input);
 3348  
 
 3349  0
                 throw nvae;
 3350  
 
 3351  
             }
 3352  
 
 3353  70
             switch (alt28) {
 3354  
                 case 1 :
 3355  
                     // com\\googlecode\\sparkleg\\Sparql.g:142:7: builtInCall
 3356  
                     {
 3357  0
                     pushFollow(FOLLOW_builtInCall_in_groupCondition870);
 3358  0
                     builtInCall69=builtInCall();
 3359  
 
 3360  0
                     state._fsp--;
 3361  
 
 3362  0
                     stream_builtInCall.add(builtInCall69.getTree());
 3363  
 
 3364  
                     // AST REWRITE
 3365  
                     // elements: builtInCall
 3366  
                     // token labels: 
 3367  
                     // rule labels: retval
 3368  
                     // token list labels: 
 3369  
                     // rule list labels: 
 3370  
                     // wildcard labels: 
 3371  0
                     retval.tree = root_0;
 3372  0
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 3373  
 
 3374  0
                     root_0 = (Object)adaptor.nil();
 3375  
                     // 142:19: -> ^( GROUP_CONDITION builtInCall )
 3376  
                     {
 3377  
                         // com\\googlecode\\sparkleg\\Sparql.g:142:22: ^( GROUP_CONDITION builtInCall )
 3378  
                         {
 3379  0
                         Object root_1 = (Object)adaptor.nil();
 3380  0
                         root_1 = (Object)adaptor.becomeRoot(
 3381  
                         (Object)adaptor.create(GROUP_CONDITION, "GROUP_CONDITION")
 3382  
                         , root_1);
 3383  
 
 3384  0
                         adaptor.addChild(root_1, stream_builtInCall.nextTree());
 3385  
 
 3386  0
                         adaptor.addChild(root_0, root_1);
 3387  
                         }
 3388  
 
 3389  
                     }
 3390  
 
 3391  
 
 3392  0
                     retval.tree = root_0;
 3393  
 
 3394  
                     }
 3395  0
                     break;
 3396  
                 case 2 :
 3397  
                     // com\\googlecode\\sparkleg\\Sparql.g:143:7: functionCall
 3398  
                     {
 3399  0
                     pushFollow(FOLLOW_functionCall_in_groupCondition886);
 3400  0
                     functionCall70=functionCall();
 3401  
 
 3402  0
                     state._fsp--;
 3403  
 
 3404  0
                     stream_functionCall.add(functionCall70.getTree());
 3405  
 
 3406  
                     // AST REWRITE
 3407  
                     // elements: functionCall
 3408  
                     // token labels: 
 3409  
                     // rule labels: retval
 3410  
                     // token list labels: 
 3411  
                     // rule list labels: 
 3412  
                     // wildcard labels: 
 3413  0
                     retval.tree = root_0;
 3414  0
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 3415  
 
 3416  0
                     root_0 = (Object)adaptor.nil();
 3417  
                     // 143:20: -> ^( GROUP_CONDITION functionCall )
 3418  
                     {
 3419  
                         // com\\googlecode\\sparkleg\\Sparql.g:143:23: ^( GROUP_CONDITION functionCall )
 3420  
                         {
 3421  0
                         Object root_1 = (Object)adaptor.nil();
 3422  0
                         root_1 = (Object)adaptor.becomeRoot(
 3423  
                         (Object)adaptor.create(GROUP_CONDITION, "GROUP_CONDITION")
 3424  
                         , root_1);
 3425  
 
 3426  0
                         adaptor.addChild(root_1, stream_functionCall.nextTree());
 3427  
 
 3428  0
                         adaptor.addChild(root_0, root_1);
 3429  
                         }
 3430  
 
 3431  
                     }
 3432  
 
 3433  
 
 3434  0
                     retval.tree = root_0;
 3435  
 
 3436  
                     }
 3437  0
                     break;
 3438  
                 case 3 :
 3439  
                     // com\\googlecode\\sparkleg\\Sparql.g:144:7: OPEN_BRACE expression ( AS var )? CLOSE_BRACE
 3440  
                     {
 3441  12
                     OPEN_BRACE71=(Token)match(input,OPEN_BRACE,FOLLOW_OPEN_BRACE_in_groupCondition902);  
 3442  12
                     stream_OPEN_BRACE.add(OPEN_BRACE71);
 3443  
 
 3444  
 
 3445  12
                     pushFollow(FOLLOW_expression_in_groupCondition904);
 3446  12
                     expression72=expression();
 3447  
 
 3448  12
                     state._fsp--;
 3449  
 
 3450  12
                     stream_expression.add(expression72.getTree());
 3451  
 
 3452  
                     // com\\googlecode\\sparkleg\\Sparql.g:144:29: ( AS var )?
 3453  12
                     int alt27=2;
 3454  12
                     switch ( input.LA(1) ) {
 3455  
                         case AS:
 3456  
                             {
 3457  4
                             alt27=1;
 3458  
                             }
 3459  
                             break;
 3460  
                     }
 3461  
 
 3462  12
                     switch (alt27) {
 3463  
                         case 1 :
 3464  
                             // com\\googlecode\\sparkleg\\Sparql.g:144:30: AS var
 3465  
                             {
 3466  4
                             AS73=(Token)match(input,AS,FOLLOW_AS_in_groupCondition907);  
 3467  4
                             stream_AS.add(AS73);
 3468  
 
 3469  
 
 3470  4
                             pushFollow(FOLLOW_var_in_groupCondition909);
 3471  4
                             var74=var();
 3472  
 
 3473  4
                             state._fsp--;
 3474  
 
 3475  4
                             stream_var.add(var74.getTree());
 3476  
 
 3477  
                             }
 3478  
                             break;
 3479  
 
 3480  
                     }
 3481  
 
 3482  
 
 3483  12
                     CLOSE_BRACE75=(Token)match(input,CLOSE_BRACE,FOLLOW_CLOSE_BRACE_in_groupCondition913);  
 3484  12
                     stream_CLOSE_BRACE.add(CLOSE_BRACE75);
 3485  
 
 3486  
 
 3487  
                     // AST REWRITE
 3488  
                     // elements: expression, var
 3489  
                     // token labels: 
 3490  
                     // rule labels: retval
 3491  
                     // token list labels: 
 3492  
                     // rule list labels: 
 3493  
                     // wildcard labels: 
 3494  12
                     retval.tree = root_0;
 3495  12
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 3496  
 
 3497  12
                     root_0 = (Object)adaptor.nil();
 3498  
                     // 144:51: -> ^( GROUP_CONDITION expression ( var )? )
 3499  
                     {
 3500  
                         // com\\googlecode\\sparkleg\\Sparql.g:144:54: ^( GROUP_CONDITION expression ( var )? )
 3501  
                         {
 3502  12
                         Object root_1 = (Object)adaptor.nil();
 3503  12
                         root_1 = (Object)adaptor.becomeRoot(
 3504  
                         (Object)adaptor.create(GROUP_CONDITION, "GROUP_CONDITION")
 3505  
                         , root_1);
 3506  
 
 3507  12
                         adaptor.addChild(root_1, stream_expression.nextTree());
 3508  
 
 3509  
                         // com\\googlecode\\sparkleg\\Sparql.g:144:83: ( var )?
 3510  12
                         if ( stream_var.hasNext() ) {
 3511  4
                             adaptor.addChild(root_1, stream_var.nextTree());
 3512  
 
 3513  
                         }
 3514  12
                         stream_var.reset();
 3515  
 
 3516  12
                         adaptor.addChild(root_0, root_1);
 3517  
                         }
 3518  
 
 3519  
                     }
 3520  
 
 3521  
 
 3522  12
                     retval.tree = root_0;
 3523  
 
 3524  
                     }
 3525  12
                     break;
 3526  
                 case 4 :
 3527  
                     // com\\googlecode\\sparkleg\\Sparql.g:145:7: var
 3528  
                     {
 3529  58
                     pushFollow(FOLLOW_var_in_groupCondition932);
 3530  58
                     var76=var();
 3531  
 
 3532  58
                     state._fsp--;
 3533  
 
 3534  58
                     stream_var.add(var76.getTree());
 3535  
 
 3536  
                     // AST REWRITE
 3537  
                     // elements: var
 3538  
                     // token labels: 
 3539  
                     // rule labels: retval
 3540  
                     // token list labels: 
 3541  
                     // rule list labels: 
 3542  
                     // wildcard labels: 
 3543  58
                     retval.tree = root_0;
 3544  58
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 3545  
 
 3546  58
                     root_0 = (Object)adaptor.nil();
 3547  
                     // 145:11: -> ^( GROUP_CONDITION var )
 3548  
                     {
 3549  
                         // com\\googlecode\\sparkleg\\Sparql.g:145:14: ^( GROUP_CONDITION var )
 3550  
                         {
 3551  58
                         Object root_1 = (Object)adaptor.nil();
 3552  58
                         root_1 = (Object)adaptor.becomeRoot(
 3553  
                         (Object)adaptor.create(GROUP_CONDITION, "GROUP_CONDITION")
 3554  
                         , root_1);
 3555  
 
 3556  58
                         adaptor.addChild(root_1, stream_var.nextTree());
 3557  
 
 3558  58
                         adaptor.addChild(root_0, root_1);
 3559  
                         }
 3560  
 
 3561  
                     }
 3562  
 
 3563  
 
 3564  58
                     retval.tree = root_0;
 3565  
 
 3566  
                     }
 3567  
                     break;
 3568  
 
 3569  
             }
 3570  70
             retval.stop = input.LT(-1);
 3571  
 
 3572  
 
 3573  70
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 3574  70
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 3575  
 
 3576  
         }
 3577  0
         catch (RecognitionException re) {
 3578  0
             reportError(re);
 3579  0
             recover(input,re);
 3580  0
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 3581  
 
 3582  
         }
 3583  
 
 3584  0
         finally {
 3585  
                 // do for sure before leaving
 3586  70
         }
 3587  70
         return retval;
 3588  
     }
 3589  
     // $ANTLR end "groupCondition"
 3590  
 
 3591  
 
 3592  16
     public static class havingClause_return extends ParserRuleReturnScope {
 3593  
         Object tree;
 3594  16
         public Object getTree() { return tree; }
 3595  
     };
 3596  
 
 3597  
 
 3598  
     // $ANTLR start "havingClause"
 3599  
     // com\\googlecode\\sparkleg\\Sparql.g:148:1: havingClause : HAVING ( constraint )+ -> ^( HAVING ( constraint )+ ) ;
 3600  
     public final SparqlParser.havingClause_return havingClause() throws RecognitionException {
 3601  16
         SparqlParser.havingClause_return retval = new SparqlParser.havingClause_return();
 3602  16
         retval.start = input.LT(1);
 3603  
 
 3604  
 
 3605  16
         Object root_0 = null;
 3606  
 
 3607  16
         Token HAVING77=null;
 3608  16
         SparqlParser.constraint_return constraint78 =null;
 3609  
 
 3610  
 
 3611  16
         Object HAVING77_tree=null;
 3612  16
         RewriteRuleTokenStream stream_HAVING=new RewriteRuleTokenStream(adaptor,"token HAVING");
 3613  16
         RewriteRuleSubtreeStream stream_constraint=new RewriteRuleSubtreeStream(adaptor,"rule constraint");
 3614  
         try {
 3615  
             // com\\googlecode\\sparkleg\\Sparql.g:149:5: ( HAVING ( constraint )+ -> ^( HAVING ( constraint )+ ) )
 3616  
             // com\\googlecode\\sparkleg\\Sparql.g:149:7: HAVING ( constraint )+
 3617  
             {
 3618  16
             HAVING77=(Token)match(input,HAVING,FOLLOW_HAVING_in_havingClause961);  
 3619  16
             stream_HAVING.add(HAVING77);
 3620  
 
 3621  
 
 3622  
             // com\\googlecode\\sparkleg\\Sparql.g:149:14: ( constraint )+
 3623  16
             int cnt29=0;
 3624  
             loop29:
 3625  
             do {
 3626  32
                 int alt29=2;
 3627  32
                 switch ( input.LA(1) ) {
 3628  
                 case ABS:
 3629  
                 case BNODE:
 3630  
                 case BOUND:
 3631  
                 case CEIL:
 3632  
                 case COALESCE:
 3633  
                 case CONCAT:
 3634  
                 case CONTAINS:
 3635  
                 case DATATYPE:
 3636  
                 case DAY:
 3637  
                 case ENCODE_FOR_URI:
 3638  
                 case EXISTS:
 3639  
                 case FLOOR:
 3640  
                 case HOURS:
 3641  
                 case IF:
 3642  
                 case IRI:
 3643  
                 case IRI_REF:
 3644  
                 case ISBLANK:
 3645  
                 case ISIRI:
 3646  
                 case ISLITERAL:
 3647  
                 case ISNUMERIC:
 3648  
                 case ISURI:
 3649  
                 case LANG:
 3650  
                 case LANGMATCHES:
 3651  
                 case LCASE:
 3652  
                 case MD5:
 3653  
                 case MINUTES:
 3654  
                 case MONTH:
 3655  
                 case NOT:
 3656  
                 case NOW:
 3657  
                 case OPEN_BRACE:
 3658  
                 case PNAME_LN:
 3659  
                 case PNAME_NS:
 3660  
                 case RAND:
 3661  
                 case REGEX:
 3662  
                 case REPLACE:
 3663  
                 case ROUND:
 3664  
                 case SAMETERM:
 3665  
                 case SECONDS:
 3666  
                 case SHA1:
 3667  
                 case SHA224:
 3668  
                 case SHA256:
 3669  
                 case SHA384:
 3670  
                 case SHA512:
 3671  
                 case STR:
 3672  
                 case STRAFTER:
 3673  
                 case STRBEFORE:
 3674  
                 case STRDT:
 3675  
                 case STRENDS:
 3676  
                 case STRLANG:
 3677  
                 case STRLEN:
 3678  
                 case STRSTARTS:
 3679  
                 case SUBSTR:
 3680  
                 case TIMEZONE:
 3681  
                 case TZ:
 3682  
                 case UCASE:
 3683  
                 case URI:
 3684  
                 case YEAR:
 3685  
                     {
 3686  16
                     alt29=1;
 3687  
                     }
 3688  
                     break;
 3689  
 
 3690  
                 }
 3691  
 
 3692  32
                 switch (alt29) {
 3693  
                     case 1 :
 3694  
                         // com\\googlecode\\sparkleg\\Sparql.g:149:14: constraint
 3695  
                         {
 3696  16
                         pushFollow(FOLLOW_constraint_in_havingClause963);
 3697  16
                         constraint78=constraint();
 3698  
 
 3699  16
                         state._fsp--;
 3700  
 
 3701  16
                         stream_constraint.add(constraint78.getTree());
 3702  
 
 3703  
                         }
 3704  16
                         break;
 3705  
 
 3706  
                     default :
 3707  16
                         if ( cnt29 >= 1 ) break loop29;
 3708  0
                         EarlyExitException eee =
 3709  
                             new EarlyExitException(29, input);
 3710  0
                         throw eee;
 3711  
                 }
 3712  16
                 cnt29++;
 3713  16
             } while (true);
 3714  
 
 3715  
 
 3716  
             // AST REWRITE
 3717  
             // elements: constraint, HAVING
 3718  
             // token labels: 
 3719  
             // rule labels: retval
 3720  
             // token list labels: 
 3721  
             // rule list labels: 
 3722  
             // wildcard labels: 
 3723  16
             retval.tree = root_0;
 3724  16
             RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 3725  
 
 3726  16
             root_0 = (Object)adaptor.nil();
 3727  
             // 149:26: -> ^( HAVING ( constraint )+ )
 3728  
             {
 3729  
                 // com\\googlecode\\sparkleg\\Sparql.g:149:29: ^( HAVING ( constraint )+ )
 3730  
                 {
 3731  16
                 Object root_1 = (Object)adaptor.nil();
 3732  16
                 root_1 = (Object)adaptor.becomeRoot(
 3733  
                 stream_HAVING.nextNode()
 3734  
                 , root_1);
 3735  
 
 3736  16
                 if ( !(stream_constraint.hasNext()) ) {
 3737  0
                     throw new RewriteEarlyExitException();
 3738  
                 }
 3739  32
                 while ( stream_constraint.hasNext() ) {
 3740  16
                     adaptor.addChild(root_1, stream_constraint.nextTree());
 3741  
 
 3742  
                 }
 3743  16
                 stream_constraint.reset();
 3744  
 
 3745  16
                 adaptor.addChild(root_0, root_1);
 3746  
                 }
 3747  
 
 3748  
             }
 3749  
 
 3750  
 
 3751  16
             retval.tree = root_0;
 3752  
 
 3753  
             }
 3754  
 
 3755  16
             retval.stop = input.LT(-1);
 3756  
 
 3757  
 
 3758  16
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 3759  16
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 3760  
 
 3761  
         }
 3762  0
         catch (RecognitionException re) {
 3763  0
             reportError(re);
 3764  0
             recover(input,re);
 3765  0
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 3766  
 
 3767  
         }
 3768  
 
 3769  0
         finally {
 3770  
                 // do for sure before leaving
 3771  16
         }
 3772  16
         return retval;
 3773  
     }
 3774  
     // $ANTLR end "havingClause"
 3775  
 
 3776  
 
 3777  134
     public static class orderClause_return extends ParserRuleReturnScope {
 3778  
         Object tree;
 3779  134
         public Object getTree() { return tree; }
 3780  
     };
 3781  
 
 3782  
 
 3783  
     // $ANTLR start "orderClause"
 3784  
     // com\\googlecode\\sparkleg\\Sparql.g:152:1: orderClause : ORDER BY ( orderCondition )+ -> ^( ORDER_BY ( orderCondition )+ ) ;
 3785  
     public final SparqlParser.orderClause_return orderClause() throws RecognitionException {
 3786  134
         SparqlParser.orderClause_return retval = new SparqlParser.orderClause_return();
 3787  134
         retval.start = input.LT(1);
 3788  
 
 3789  
 
 3790  134
         Object root_0 = null;
 3791  
 
 3792  134
         Token ORDER79=null;
 3793  134
         Token BY80=null;
 3794  134
         SparqlParser.orderCondition_return orderCondition81 =null;
 3795  
 
 3796  
 
 3797  134
         Object ORDER79_tree=null;
 3798  134
         Object BY80_tree=null;
 3799  134
         RewriteRuleTokenStream stream_BY=new RewriteRuleTokenStream(adaptor,"token BY");
 3800  134
         RewriteRuleTokenStream stream_ORDER=new RewriteRuleTokenStream(adaptor,"token ORDER");
 3801  134
         RewriteRuleSubtreeStream stream_orderCondition=new RewriteRuleSubtreeStream(adaptor,"rule orderCondition");
 3802  
         try {
 3803  
             // com\\googlecode\\sparkleg\\Sparql.g:153:5: ( ORDER BY ( orderCondition )+ -> ^( ORDER_BY ( orderCondition )+ ) )
 3804  
             // com\\googlecode\\sparkleg\\Sparql.g:153:7: ORDER BY ( orderCondition )+
 3805  
             {
 3806  134
             ORDER79=(Token)match(input,ORDER,FOLLOW_ORDER_in_orderClause995);  
 3807  134
             stream_ORDER.add(ORDER79);
 3808  
 
 3809  
 
 3810  134
             BY80=(Token)match(input,BY,FOLLOW_BY_in_orderClause997);  
 3811  134
             stream_BY.add(BY80);
 3812  
 
 3813  
 
 3814  
             // com\\googlecode\\sparkleg\\Sparql.g:153:16: ( orderCondition )+
 3815  134
             int cnt30=0;
 3816  
             loop30:
 3817  
             do {
 3818  316
                 int alt30=2;
 3819  316
                 switch ( input.LA(1) ) {
 3820  
                 case ABS:
 3821  
                 case ASC:
 3822  
                 case BNODE:
 3823  
                 case BOUND:
 3824  
                 case CEIL:
 3825  
                 case COALESCE:
 3826  
                 case CONCAT:
 3827  
                 case CONTAINS:
 3828  
                 case DATATYPE:
 3829  
                 case DAY:
 3830  
                 case DESC:
 3831  
                 case ENCODE_FOR_URI:
 3832  
                 case EXISTS:
 3833  
                 case FLOOR:
 3834  
                 case HOURS:
 3835  
                 case IF:
 3836  
                 case IRI:
 3837  
                 case IRI_REF:
 3838  
                 case ISBLANK:
 3839  
                 case ISIRI:
 3840  
                 case ISLITERAL:
 3841  
                 case ISNUMERIC:
 3842  
                 case ISURI:
 3843  
                 case LANG:
 3844  
                 case LANGMATCHES:
 3845  
                 case LCASE:
 3846  
                 case MD5:
 3847  
                 case MINUTES:
 3848  
                 case MONTH:
 3849  
                 case NOT:
 3850  
                 case NOW:
 3851  
                 case OPEN_BRACE:
 3852  
                 case PNAME_LN:
 3853  
                 case PNAME_NS:
 3854  
                 case RAND:
 3855  
                 case REGEX:
 3856  
                 case REPLACE:
 3857  
                 case ROUND:
 3858  
                 case SAMETERM:
 3859  
                 case SECONDS:
 3860  
                 case SHA1:
 3861  
                 case SHA224:
 3862  
                 case SHA256:
 3863  
                 case SHA384:
 3864  
                 case SHA512:
 3865  
                 case STR:
 3866  
                 case STRAFTER:
 3867  
                 case STRBEFORE:
 3868  
                 case STRDT:
 3869  
                 case STRENDS:
 3870  
                 case STRLANG:
 3871  
                 case STRLEN:
 3872  
                 case STRSTARTS:
 3873  
                 case SUBSTR:
 3874  
                 case TIMEZONE:
 3875  
                 case TZ:
 3876  
                 case UCASE:
 3877  
                 case URI:
 3878  
                 case VAR1:
 3879  
                 case VAR2:
 3880  
                 case YEAR:
 3881  
                     {
 3882  182
                     alt30=1;
 3883  
                     }
 3884  
                     break;
 3885  
 
 3886  
                 }
 3887  
 
 3888  316
                 switch (alt30) {
 3889  
                     case 1 :
 3890  
                         // com\\googlecode\\sparkleg\\Sparql.g:153:16: orderCondition
 3891  
                         {
 3892  182
                         pushFollow(FOLLOW_orderCondition_in_orderClause999);
 3893  182
                         orderCondition81=orderCondition();
 3894  
 
 3895  182
                         state._fsp--;
 3896  
 
 3897  182
                         stream_orderCondition.add(orderCondition81.getTree());
 3898  
 
 3899  
                         }
 3900  182
                         break;
 3901  
 
 3902  
                     default :
 3903  134
                         if ( cnt30 >= 1 ) break loop30;
 3904  0
                         EarlyExitException eee =
 3905  
                             new EarlyExitException(30, input);
 3906  0
                         throw eee;
 3907  
                 }
 3908  182
                 cnt30++;
 3909  182
             } while (true);
 3910  
 
 3911  
 
 3912  
             // AST REWRITE
 3913  
             // elements: orderCondition
 3914  
             // token labels: 
 3915  
             // rule labels: retval
 3916  
             // token list labels: 
 3917  
             // rule list labels: 
 3918  
             // wildcard labels: 
 3919  134
             retval.tree = root_0;
 3920  134
             RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 3921  
 
 3922  134
             root_0 = (Object)adaptor.nil();
 3923  
             // 153:32: -> ^( ORDER_BY ( orderCondition )+ )
 3924  
             {
 3925  
                 // com\\googlecode\\sparkleg\\Sparql.g:153:35: ^( ORDER_BY ( orderCondition )+ )
 3926  
                 {
 3927  134
                 Object root_1 = (Object)adaptor.nil();
 3928  134
                 root_1 = (Object)adaptor.becomeRoot(
 3929  
                 (Object)adaptor.create(ORDER_BY, "ORDER_BY")
 3930  
                 , root_1);
 3931  
 
 3932  134
                 if ( !(stream_orderCondition.hasNext()) ) {
 3933  0
                     throw new RewriteEarlyExitException();
 3934  
                 }
 3935  316
                 while ( stream_orderCondition.hasNext() ) {
 3936  182
                     adaptor.addChild(root_1, stream_orderCondition.nextTree());
 3937  
 
 3938  
                 }
 3939  134
                 stream_orderCondition.reset();
 3940  
 
 3941  134
                 adaptor.addChild(root_0, root_1);
 3942  
                 }
 3943  
 
 3944  
             }
 3945  
 
 3946  
 
 3947  134
             retval.tree = root_0;
 3948  
 
 3949  
             }
 3950  
 
 3951  134
             retval.stop = input.LT(-1);
 3952  
 
 3953  
 
 3954  134
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 3955  134
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 3956  
 
 3957  
         }
 3958  0
         catch (RecognitionException re) {
 3959  0
             reportError(re);
 3960  0
             recover(input,re);
 3961  0
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 3962  
 
 3963  
         }
 3964  
 
 3965  0
         finally {
 3966  
                 // do for sure before leaving
 3967  134
         }
 3968  134
         return retval;
 3969  
     }
 3970  
     // $ANTLR end "orderClause"
 3971  
 
 3972  
 
 3973  182
     public static class orderCondition_return extends ParserRuleReturnScope {
 3974  
         Object tree;
 3975  182
         public Object getTree() { return tree; }
 3976  
     };
 3977  
 
 3978  
 
 3979  
     // $ANTLR start "orderCondition"
 3980  
     // com\\googlecode\\sparkleg\\Sparql.g:156:1: orderCondition : ( ASC brackettedExpression -> ^( ORDER_CONDITION ASC brackettedExpression ) | DESC brackettedExpression -> ^( ORDER_CONDITION DESC brackettedExpression ) | constraint -> ^( ORDER_CONDITION constraint ) | var -> ^( ORDER_CONDITION var ) );
 3981  
     public final SparqlParser.orderCondition_return orderCondition() throws RecognitionException {
 3982  182
         SparqlParser.orderCondition_return retval = new SparqlParser.orderCondition_return();
 3983  182
         retval.start = input.LT(1);
 3984  
 
 3985  
 
 3986  182
         Object root_0 = null;
 3987  
 
 3988  182
         Token ASC82=null;
 3989  182
         Token DESC84=null;
 3990  182
         SparqlParser.brackettedExpression_return brackettedExpression83 =null;
 3991  
 
 3992  182
         SparqlParser.brackettedExpression_return brackettedExpression85 =null;
 3993  
 
 3994  182
         SparqlParser.constraint_return constraint86 =null;
 3995  
 
 3996  182
         SparqlParser.var_return var87 =null;
 3997  
 
 3998  
 
 3999  182
         Object ASC82_tree=null;
 4000  182
         Object DESC84_tree=null;
 4001  182
         RewriteRuleTokenStream stream_DESC=new RewriteRuleTokenStream(adaptor,"token DESC");
 4002  182
         RewriteRuleTokenStream stream_ASC=new RewriteRuleTokenStream(adaptor,"token ASC");
 4003  182
         RewriteRuleSubtreeStream stream_var=new RewriteRuleSubtreeStream(adaptor,"rule var");
 4004  182
         RewriteRuleSubtreeStream stream_constraint=new RewriteRuleSubtreeStream(adaptor,"rule constraint");
 4005  182
         RewriteRuleSubtreeStream stream_brackettedExpression=new RewriteRuleSubtreeStream(adaptor,"rule brackettedExpression");
 4006  
         try {
 4007  
             // com\\googlecode\\sparkleg\\Sparql.g:157:5: ( ASC brackettedExpression -> ^( ORDER_CONDITION ASC brackettedExpression ) | DESC brackettedExpression -> ^( ORDER_CONDITION DESC brackettedExpression ) | constraint -> ^( ORDER_CONDITION constraint ) | var -> ^( ORDER_CONDITION var ) )
 4008  182
             int alt31=4;
 4009  182
             switch ( input.LA(1) ) {
 4010  
             case ASC:
 4011  
                 {
 4012  10
                 alt31=1;
 4013  
                 }
 4014  10
                 break;
 4015  
             case DESC:
 4016  
                 {
 4017  30
                 alt31=2;
 4018  
                 }
 4019  30
                 break;
 4020  
             case ABS:
 4021  
             case BNODE:
 4022  
             case BOUND:
 4023  
             case CEIL:
 4024  
             case COALESCE:
 4025  
             case CONCAT:
 4026  
             case CONTAINS:
 4027  
             case DATATYPE:
 4028  
             case DAY:
 4029  
             case ENCODE_FOR_URI:
 4030  
             case EXISTS:
 4031  
             case FLOOR:
 4032  
             case HOURS:
 4033  
             case IF:
 4034  
             case IRI:
 4035  
             case IRI_REF:
 4036  
             case ISBLANK:
 4037  
             case ISIRI:
 4038  
             case ISLITERAL:
 4039  
             case ISNUMERIC:
 4040  
             case ISURI:
 4041  
             case LANG:
 4042  
             case LANGMATCHES:
 4043  
             case LCASE:
 4044  
             case MD5:
 4045  
             case MINUTES:
 4046  
             case MONTH:
 4047  
             case NOT:
 4048  
             case NOW:
 4049  
             case OPEN_BRACE:
 4050  
             case PNAME_LN:
 4051  
             case PNAME_NS:
 4052  
             case RAND:
 4053  
             case REGEX:
 4054  
             case REPLACE:
 4055  
             case ROUND:
 4056  
             case SAMETERM:
 4057  
             case SECONDS:
 4058  
             case SHA1:
 4059  
             case SHA224:
 4060  
             case SHA256:
 4061  
             case SHA384:
 4062  
             case SHA512:
 4063  
             case STR:
 4064  
             case STRAFTER:
 4065  
             case STRBEFORE:
 4066  
             case STRDT:
 4067  
             case STRENDS:
 4068  
             case STRLANG:
 4069  
             case STRLEN:
 4070  
             case STRSTARTS:
 4071  
             case SUBSTR:
 4072  
             case TIMEZONE:
 4073  
             case TZ:
 4074  
             case UCASE:
 4075  
             case URI:
 4076  
             case YEAR:
 4077  
                 {
 4078  12
                 alt31=3;
 4079  
                 }
 4080  12
                 break;
 4081  
             case VAR1:
 4082  
             case VAR2:
 4083  
                 {
 4084  130
                 alt31=4;
 4085  
                 }
 4086  130
                 break;
 4087  
             default:
 4088  0
                 NoViableAltException nvae =
 4089  
                     new NoViableAltException("", 31, 0, input);
 4090  
 
 4091  0
                 throw nvae;
 4092  
 
 4093  
             }
 4094  
 
 4095  182
             switch (alt31) {
 4096  
                 case 1 :
 4097  
                     // com\\googlecode\\sparkleg\\Sparql.g:157:7: ASC brackettedExpression
 4098  
                     {
 4099  10
                     ASC82=(Token)match(input,ASC,FOLLOW_ASC_in_orderCondition1026);  
 4100  10
                     stream_ASC.add(ASC82);
 4101  
 
 4102  
 
 4103  10
                     pushFollow(FOLLOW_brackettedExpression_in_orderCondition1028);
 4104  10
                     brackettedExpression83=brackettedExpression();
 4105  
 
 4106  10
                     state._fsp--;
 4107  
 
 4108  10
                     stream_brackettedExpression.add(brackettedExpression83.getTree());
 4109  
 
 4110  
                     // AST REWRITE
 4111  
                     // elements: brackettedExpression, ASC
 4112  
                     // token labels: 
 4113  
                     // rule labels: retval
 4114  
                     // token list labels: 
 4115  
                     // rule list labels: 
 4116  
                     // wildcard labels: 
 4117  10
                     retval.tree = root_0;
 4118  10
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 4119  
 
 4120  10
                     root_0 = (Object)adaptor.nil();
 4121  
                     // 157:32: -> ^( ORDER_CONDITION ASC brackettedExpression )
 4122  
                     {
 4123  
                         // com\\googlecode\\sparkleg\\Sparql.g:157:35: ^( ORDER_CONDITION ASC brackettedExpression )
 4124  
                         {
 4125  10
                         Object root_1 = (Object)adaptor.nil();
 4126  10
                         root_1 = (Object)adaptor.becomeRoot(
 4127  
                         (Object)adaptor.create(ORDER_CONDITION, "ORDER_CONDITION")
 4128  
                         , root_1);
 4129  
 
 4130  10
                         adaptor.addChild(root_1, 
 4131  
                         stream_ASC.nextNode()
 4132  
                         );
 4133  
 
 4134  10
                         adaptor.addChild(root_1, stream_brackettedExpression.nextTree());
 4135  
 
 4136  10
                         adaptor.addChild(root_0, root_1);
 4137  
                         }
 4138  
 
 4139  
                     }
 4140  
 
 4141  
 
 4142  10
                     retval.tree = root_0;
 4143  
 
 4144  
                     }
 4145  10
                     break;
 4146  
                 case 2 :
 4147  
                     // com\\googlecode\\sparkleg\\Sparql.g:158:7: DESC brackettedExpression
 4148  
                     {
 4149  30
                     DESC84=(Token)match(input,DESC,FOLLOW_DESC_in_orderCondition1046);  
 4150  30
                     stream_DESC.add(DESC84);
 4151  
 
 4152  
 
 4153  30
                     pushFollow(FOLLOW_brackettedExpression_in_orderCondition1048);
 4154  30
                     brackettedExpression85=brackettedExpression();
 4155  
 
 4156  30
                     state._fsp--;
 4157  
 
 4158  30
                     stream_brackettedExpression.add(brackettedExpression85.getTree());
 4159  
 
 4160  
                     // AST REWRITE
 4161  
                     // elements: brackettedExpression, DESC
 4162  
                     // token labels: 
 4163  
                     // rule labels: retval
 4164  
                     // token list labels: 
 4165  
                     // rule list labels: 
 4166  
                     // wildcard labels: 
 4167  30
                     retval.tree = root_0;
 4168  30
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 4169  
 
 4170  30
                     root_0 = (Object)adaptor.nil();
 4171  
                     // 158:33: -> ^( ORDER_CONDITION DESC brackettedExpression )
 4172  
                     {
 4173  
                         // com\\googlecode\\sparkleg\\Sparql.g:158:36: ^( ORDER_CONDITION DESC brackettedExpression )
 4174  
                         {
 4175  30
                         Object root_1 = (Object)adaptor.nil();
 4176  30
                         root_1 = (Object)adaptor.becomeRoot(
 4177  
                         (Object)adaptor.create(ORDER_CONDITION, "ORDER_CONDITION")
 4178  
                         , root_1);
 4179  
 
 4180  30
                         adaptor.addChild(root_1, 
 4181  
                         stream_DESC.nextNode()
 4182  
                         );
 4183  
 
 4184  30
                         adaptor.addChild(root_1, stream_brackettedExpression.nextTree());
 4185  
 
 4186  30
                         adaptor.addChild(root_0, root_1);
 4187  
                         }
 4188  
 
 4189  
                     }
 4190  
 
 4191  
 
 4192  30
                     retval.tree = root_0;
 4193  
 
 4194  
                     }
 4195  30
                     break;
 4196  
                 case 3 :
 4197  
                     // com\\googlecode\\sparkleg\\Sparql.g:159:7: constraint
 4198  
                     {
 4199  12
                     pushFollow(FOLLOW_constraint_in_orderCondition1066);
 4200  12
                     constraint86=constraint();
 4201  
 
 4202  12
                     state._fsp--;
 4203  
 
 4204  12
                     stream_constraint.add(constraint86.getTree());
 4205  
 
 4206  
                     // AST REWRITE
 4207  
                     // elements: constraint
 4208  
                     // token labels: 
 4209  
                     // rule labels: retval
 4210  
                     // token list labels: 
 4211  
                     // rule list labels: 
 4212  
                     // wildcard labels: 
 4213  12
                     retval.tree = root_0;
 4214  12
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 4215  
 
 4216  12
                     root_0 = (Object)adaptor.nil();
 4217  
                     // 159:18: -> ^( ORDER_CONDITION constraint )
 4218  
                     {
 4219  
                         // com\\googlecode\\sparkleg\\Sparql.g:159:21: ^( ORDER_CONDITION constraint )
 4220  
                         {
 4221  12
                         Object root_1 = (Object)adaptor.nil();
 4222  12
                         root_1 = (Object)adaptor.becomeRoot(
 4223  
                         (Object)adaptor.create(ORDER_CONDITION, "ORDER_CONDITION")
 4224  
                         , root_1);
 4225  
 
 4226  12
                         adaptor.addChild(root_1, stream_constraint.nextTree());
 4227  
 
 4228  12
                         adaptor.addChild(root_0, root_1);
 4229  
                         }
 4230  
 
 4231  
                     }
 4232  
 
 4233  
 
 4234  12
                     retval.tree = root_0;
 4235  
 
 4236  
                     }
 4237  12
                     break;
 4238  
                 case 4 :
 4239  
                     // com\\googlecode\\sparkleg\\Sparql.g:160:7: var
 4240  
                     {
 4241  130
                     pushFollow(FOLLOW_var_in_orderCondition1082);
 4242  130
                     var87=var();
 4243  
 
 4244  130
                     state._fsp--;
 4245  
 
 4246  130
                     stream_var.add(var87.getTree());
 4247  
 
 4248  
                     // AST REWRITE
 4249  
                     // elements: var
 4250  
                     // token labels: 
 4251  
                     // rule labels: retval
 4252  
                     // token list labels: 
 4253  
                     // rule list labels: 
 4254  
                     // wildcard labels: 
 4255  130
                     retval.tree = root_0;
 4256  130
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 4257  
 
 4258  130
                     root_0 = (Object)adaptor.nil();
 4259  
                     // 160:11: -> ^( ORDER_CONDITION var )
 4260  
                     {
 4261  
                         // com\\googlecode\\sparkleg\\Sparql.g:160:14: ^( ORDER_CONDITION var )
 4262  
                         {
 4263  130
                         Object root_1 = (Object)adaptor.nil();
 4264  130
                         root_1 = (Object)adaptor.becomeRoot(
 4265  
                         (Object)adaptor.create(ORDER_CONDITION, "ORDER_CONDITION")
 4266  
                         , root_1);
 4267  
 
 4268  130
                         adaptor.addChild(root_1, stream_var.nextTree());
 4269  
 
 4270  130
                         adaptor.addChild(root_0, root_1);
 4271  
                         }
 4272  
 
 4273  
                     }
 4274  
 
 4275  
 
 4276  130
                     retval.tree = root_0;
 4277  
 
 4278  
                     }
 4279  
                     break;
 4280  
 
 4281  
             }
 4282  182
             retval.stop = input.LT(-1);
 4283  
 
 4284  
 
 4285  182
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 4286  182
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 4287  
 
 4288  
         }
 4289  0
         catch (RecognitionException re) {
 4290  0
             reportError(re);
 4291  0
             recover(input,re);
 4292  0
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 4293  
 
 4294  
         }
 4295  
 
 4296  0
         finally {
 4297  
                 // do for sure before leaving
 4298  182
         }
 4299  182
         return retval;
 4300  
     }
 4301  
     // $ANTLR end "orderCondition"
 4302  
 
 4303  
 
 4304  58
     public static class limitOffsetClauses_return extends ParserRuleReturnScope {
 4305  
         Object tree;
 4306  58
         public Object getTree() { return tree; }
 4307  
     };
 4308  
 
 4309  
 
 4310  
     // $ANTLR start "limitOffsetClauses"
 4311  
     // com\\googlecode\\sparkleg\\Sparql.g:163:1: limitOffsetClauses : ( limitClause ( offsetClause )? -> limitClause ( offsetClause )* | offsetClause ( limitClause )? -> offsetClause ( limitClause )* );
 4312  
     public final SparqlParser.limitOffsetClauses_return limitOffsetClauses() throws RecognitionException {
 4313  58
         SparqlParser.limitOffsetClauses_return retval = new SparqlParser.limitOffsetClauses_return();
 4314  58
         retval.start = input.LT(1);
 4315  
 
 4316  
 
 4317  58
         Object root_0 = null;
 4318  
 
 4319  58
         SparqlParser.limitClause_return limitClause88 =null;
 4320  
 
 4321  58
         SparqlParser.offsetClause_return offsetClause89 =null;
 4322  
 
 4323  58
         SparqlParser.offsetClause_return offsetClause90 =null;
 4324  
 
 4325  58
         SparqlParser.limitClause_return limitClause91 =null;
 4326  
 
 4327  
 
 4328  58
         RewriteRuleSubtreeStream stream_offsetClause=new RewriteRuleSubtreeStream(adaptor,"rule offsetClause");
 4329  58
         RewriteRuleSubtreeStream stream_limitClause=new RewriteRuleSubtreeStream(adaptor,"rule limitClause");
 4330  
         try {
 4331  
             // com\\googlecode\\sparkleg\\Sparql.g:164:5: ( limitClause ( offsetClause )? -> limitClause ( offsetClause )* | offsetClause ( limitClause )? -> offsetClause ( limitClause )* )
 4332  58
             int alt34=2;
 4333  58
             switch ( input.LA(1) ) {
 4334  
             case LIMIT:
 4335  
                 {
 4336  43
                 alt34=1;
 4337  
                 }
 4338  43
                 break;
 4339  
             case OFFSET:
 4340  
                 {
 4341  15
                 alt34=2;
 4342  
                 }
 4343  15
                 break;
 4344  
             default:
 4345  0
                 NoViableAltException nvae =
 4346  
                     new NoViableAltException("", 34, 0, input);
 4347  
 
 4348  0
                 throw nvae;
 4349  
 
 4350  
             }
 4351  
 
 4352  58
             switch (alt34) {
 4353  
                 case 1 :
 4354  
                     // com\\googlecode\\sparkleg\\Sparql.g:164:7: limitClause ( offsetClause )?
 4355  
                     {
 4356  43
                     pushFollow(FOLLOW_limitClause_in_limitOffsetClauses1112);
 4357  43
                     limitClause88=limitClause();
 4358  
 
 4359  43
                     state._fsp--;
 4360  
 
 4361  43
                     stream_limitClause.add(limitClause88.getTree());
 4362  
 
 4363  
                     // com\\googlecode\\sparkleg\\Sparql.g:164:19: ( offsetClause )?
 4364  43
                     int alt32=2;
 4365  43
                     switch ( input.LA(1) ) {
 4366  
                         case OFFSET:
 4367  
                             {
 4368  17
                             alt32=1;
 4369  
                             }
 4370  
                             break;
 4371  
                     }
 4372  
 
 4373  43
                     switch (alt32) {
 4374  
                         case 1 :
 4375  
                             // com\\googlecode\\sparkleg\\Sparql.g:164:19: offsetClause
 4376  
                             {
 4377  17
                             pushFollow(FOLLOW_offsetClause_in_limitOffsetClauses1114);
 4378  17
                             offsetClause89=offsetClause();
 4379  
 
 4380  17
                             state._fsp--;
 4381  
 
 4382  17
                             stream_offsetClause.add(offsetClause89.getTree());
 4383  
 
 4384  
                             }
 4385  
                             break;
 4386  
 
 4387  
                     }
 4388  
 
 4389  
 
 4390  
                     // AST REWRITE
 4391  
                     // elements: offsetClause, limitClause
 4392  
                     // token labels: 
 4393  
                     // rule labels: retval
 4394  
                     // token list labels: 
 4395  
                     // rule list labels: 
 4396  
                     // wildcard labels: 
 4397  43
                     retval.tree = root_0;
 4398  43
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 4399  
 
 4400  43
                     root_0 = (Object)adaptor.nil();
 4401  
                     // 164:33: -> limitClause ( offsetClause )*
 4402  
                     {
 4403  43
                         adaptor.addChild(root_0, stream_limitClause.nextTree());
 4404  
 
 4405  
                         // com\\googlecode\\sparkleg\\Sparql.g:164:48: ( offsetClause )*
 4406  60
                         while ( stream_offsetClause.hasNext() ) {
 4407  17
                             adaptor.addChild(root_0, stream_offsetClause.nextTree());
 4408  
 
 4409  
                         }
 4410  43
                         stream_offsetClause.reset();
 4411  
 
 4412  
                     }
 4413  
 
 4414  
 
 4415  43
                     retval.tree = root_0;
 4416  
 
 4417  
                     }
 4418  43
                     break;
 4419  
                 case 2 :
 4420  
                     // com\\googlecode\\sparkleg\\Sparql.g:165:7: offsetClause ( limitClause )?
 4421  
                     {
 4422  15
                     pushFollow(FOLLOW_offsetClause_in_limitOffsetClauses1130);
 4423  15
                     offsetClause90=offsetClause();
 4424  
 
 4425  15
                     state._fsp--;
 4426  
 
 4427  15
                     stream_offsetClause.add(offsetClause90.getTree());
 4428  
 
 4429  
                     // com\\googlecode\\sparkleg\\Sparql.g:165:20: ( limitClause )?
 4430  15
                     int alt33=2;
 4431  15
                     switch ( input.LA(1) ) {
 4432  
                         case LIMIT:
 4433  
                             {
 4434  5
                             alt33=1;
 4435  
                             }
 4436  
                             break;
 4437  
                     }
 4438  
 
 4439  15
                     switch (alt33) {
 4440  
                         case 1 :
 4441  
                             // com\\googlecode\\sparkleg\\Sparql.g:165:20: limitClause
 4442  
                             {
 4443  5
                             pushFollow(FOLLOW_limitClause_in_limitOffsetClauses1132);
 4444  5
                             limitClause91=limitClause();
 4445  
 
 4446  5
                             state._fsp--;
 4447  
 
 4448  5
                             stream_limitClause.add(limitClause91.getTree());
 4449  
 
 4450  
                             }
 4451  
                             break;
 4452  
 
 4453  
                     }
 4454  
 
 4455  
 
 4456  
                     // AST REWRITE
 4457  
                     // elements: offsetClause, limitClause
 4458  
                     // token labels: 
 4459  
                     // rule labels: retval
 4460  
                     // token list labels: 
 4461  
                     // rule list labels: 
 4462  
                     // wildcard labels: 
 4463  15
                     retval.tree = root_0;
 4464  15
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 4465  
 
 4466  15
                     root_0 = (Object)adaptor.nil();
 4467  
                     // 165:33: -> offsetClause ( limitClause )*
 4468  
                     {
 4469  15
                         adaptor.addChild(root_0, stream_offsetClause.nextTree());
 4470  
 
 4471  
                         // com\\googlecode\\sparkleg\\Sparql.g:165:49: ( limitClause )*
 4472  20
                         while ( stream_limitClause.hasNext() ) {
 4473  5
                             adaptor.addChild(root_0, stream_limitClause.nextTree());
 4474  
 
 4475  
                         }
 4476  15
                         stream_limitClause.reset();
 4477  
 
 4478  
                     }
 4479  
 
 4480  
 
 4481  15
                     retval.tree = root_0;
 4482  
 
 4483  
                     }
 4484  
                     break;
 4485  
 
 4486  
             }
 4487  58
             retval.stop = input.LT(-1);
 4488  
 
 4489  
 
 4490  58
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 4491  58
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 4492  
 
 4493  
         }
 4494  0
         catch (RecognitionException re) {
 4495  0
             reportError(re);
 4496  0
             recover(input,re);
 4497  0
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 4498  
 
 4499  
         }
 4500  
 
 4501  0
         finally {
 4502  
                 // do for sure before leaving
 4503  58
         }
 4504  58
         return retval;
 4505  
     }
 4506  
     // $ANTLR end "limitOffsetClauses"
 4507  
 
 4508  
 
 4509  48
     public static class limitClause_return extends ParserRuleReturnScope {
 4510  
         Object tree;
 4511  48
         public Object getTree() { return tree; }
 4512  
     };
 4513  
 
 4514  
 
 4515  
     // $ANTLR start "limitClause"
 4516  
     // com\\googlecode\\sparkleg\\Sparql.g:168:1: limitClause : LIMIT INTEGER -> ^( LIMIT INTEGER ) ;
 4517  
     public final SparqlParser.limitClause_return limitClause() throws RecognitionException {
 4518  48
         SparqlParser.limitClause_return retval = new SparqlParser.limitClause_return();
 4519  48
         retval.start = input.LT(1);
 4520  
 
 4521  
 
 4522  48
         Object root_0 = null;
 4523  
 
 4524  48
         Token LIMIT92=null;
 4525  48
         Token INTEGER93=null;
 4526  
 
 4527  48
         Object LIMIT92_tree=null;
 4528  48
         Object INTEGER93_tree=null;
 4529  48
         RewriteRuleTokenStream stream_INTEGER=new RewriteRuleTokenStream(adaptor,"token INTEGER");
 4530  48
         RewriteRuleTokenStream stream_LIMIT=new RewriteRuleTokenStream(adaptor,"token LIMIT");
 4531  
 
 4532  
         try {
 4533  
             // com\\googlecode\\sparkleg\\Sparql.g:169:5: ( LIMIT INTEGER -> ^( LIMIT INTEGER ) )
 4534  
             // com\\googlecode\\sparkleg\\Sparql.g:169:7: LIMIT INTEGER
 4535  
             {
 4536  48
             LIMIT92=(Token)match(input,LIMIT,FOLLOW_LIMIT_in_limitClause1157);  
 4537  48
             stream_LIMIT.add(LIMIT92);
 4538  
 
 4539  
 
 4540  48
             INTEGER93=(Token)match(input,INTEGER,FOLLOW_INTEGER_in_limitClause1159);  
 4541  48
             stream_INTEGER.add(INTEGER93);
 4542  
 
 4543  
 
 4544  
             // AST REWRITE
 4545  
             // elements: LIMIT, INTEGER
 4546  
             // token labels: 
 4547  
             // rule labels: retval
 4548  
             // token list labels: 
 4549  
             // rule list labels: 
 4550  
             // wildcard labels: 
 4551  48
             retval.tree = root_0;
 4552  48
             RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 4553  
 
 4554  48
             root_0 = (Object)adaptor.nil();
 4555  
             // 169:21: -> ^( LIMIT INTEGER )
 4556  
             {
 4557  
                 // com\\googlecode\\sparkleg\\Sparql.g:169:24: ^( LIMIT INTEGER )
 4558  
                 {
 4559  48
                 Object root_1 = (Object)adaptor.nil();
 4560  48
                 root_1 = (Object)adaptor.becomeRoot(
 4561  
                 stream_LIMIT.nextNode()
 4562  
                 , root_1);
 4563  
 
 4564  48
                 adaptor.addChild(root_1, 
 4565  
                 stream_INTEGER.nextNode()
 4566  
                 );
 4567  
 
 4568  48
                 adaptor.addChild(root_0, root_1);
 4569  
                 }
 4570  
 
 4571  
             }
 4572  
 
 4573  
 
 4574  48
             retval.tree = root_0;
 4575  
 
 4576  
             }
 4577  
 
 4578  48
             retval.stop = input.LT(-1);
 4579  
 
 4580  
 
 4581  48
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 4582  48
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 4583  
 
 4584  
         }
 4585  0
         catch (RecognitionException re) {
 4586  0
             reportError(re);
 4587  0
             recover(input,re);
 4588  0
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 4589  
 
 4590  
         }
 4591  
 
 4592  0
         finally {
 4593  
                 // do for sure before leaving
 4594  48
         }
 4595  48
         return retval;
 4596  
     }
 4597  
     // $ANTLR end "limitClause"
 4598  
 
 4599  
 
 4600  32
     public static class offsetClause_return extends ParserRuleReturnScope {
 4601  
         Object tree;
 4602  32
         public Object getTree() { return tree; }
 4603  
     };
 4604  
 
 4605  
 
 4606  
     // $ANTLR start "offsetClause"
 4607  
     // com\\googlecode\\sparkleg\\Sparql.g:172:1: offsetClause : OFFSET INTEGER -> ^( OFFSET INTEGER ) ;
 4608  
     public final SparqlParser.offsetClause_return offsetClause() throws RecognitionException {
 4609  32
         SparqlParser.offsetClause_return retval = new SparqlParser.offsetClause_return();
 4610  32
         retval.start = input.LT(1);
 4611  
 
 4612  
 
 4613  32
         Object root_0 = null;
 4614  
 
 4615  32
         Token OFFSET94=null;
 4616  32
         Token INTEGER95=null;
 4617  
 
 4618  32
         Object OFFSET94_tree=null;
 4619  32
         Object INTEGER95_tree=null;
 4620  32
         RewriteRuleTokenStream stream_INTEGER=new RewriteRuleTokenStream(adaptor,"token INTEGER");
 4621  32
         RewriteRuleTokenStream stream_OFFSET=new RewriteRuleTokenStream(adaptor,"token OFFSET");
 4622  
 
 4623  
         try {
 4624  
             // com\\googlecode\\sparkleg\\Sparql.g:173:5: ( OFFSET INTEGER -> ^( OFFSET INTEGER ) )
 4625  
             // com\\googlecode\\sparkleg\\Sparql.g:173:7: OFFSET INTEGER
 4626  
             {
 4627  32
             OFFSET94=(Token)match(input,OFFSET,FOLLOW_OFFSET_in_offsetClause1184);  
 4628  32
             stream_OFFSET.add(OFFSET94);
 4629  
 
 4630  
 
 4631  32
             INTEGER95=(Token)match(input,INTEGER,FOLLOW_INTEGER_in_offsetClause1186);  
 4632  32
             stream_INTEGER.add(INTEGER95);
 4633  
 
 4634  
 
 4635  
             // AST REWRITE
 4636  
             // elements: OFFSET, INTEGER
 4637  
             // token labels: 
 4638  
             // rule labels: retval
 4639  
             // token list labels: 
 4640  
             // rule list labels: 
 4641  
             // wildcard labels: 
 4642  32
             retval.tree = root_0;
 4643  32
             RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 4644  
 
 4645  32
             root_0 = (Object)adaptor.nil();
 4646  
             // 173:22: -> ^( OFFSET INTEGER )
 4647  
             {
 4648  
                 // com\\googlecode\\sparkleg\\Sparql.g:173:25: ^( OFFSET INTEGER )
 4649  
                 {
 4650  32
                 Object root_1 = (Object)adaptor.nil();
 4651  32
                 root_1 = (Object)adaptor.becomeRoot(
 4652  
                 stream_OFFSET.nextNode()
 4653  
                 , root_1);
 4654  
 
 4655  32
                 adaptor.addChild(root_1, 
 4656  
                 stream_INTEGER.nextNode()
 4657  
                 );
 4658  
 
 4659  32
                 adaptor.addChild(root_0, root_1);
 4660  
                 }
 4661  
 
 4662  
             }
 4663  
 
 4664  
 
 4665  32
             retval.tree = root_0;
 4666  
 
 4667  
             }
 4668  
 
 4669  32
             retval.stop = input.LT(-1);
 4670  
 
 4671  
 
 4672  32
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 4673  32
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 4674  
 
 4675  
         }
 4676  0
         catch (RecognitionException re) {
 4677  0
             reportError(re);
 4678  0
             recover(input,re);
 4679  0
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 4680  
 
 4681  
         }
 4682  
 
 4683  0
         finally {
 4684  
                 // do for sure before leaving
 4685  32
         }
 4686  32
         return retval;
 4687  
     }
 4688  
     // $ANTLR end "offsetClause"
 4689  
 
 4690  
 
 4691  1774
     public static class bindingsClause_return extends ParserRuleReturnScope {
 4692  
         Object tree;
 4693  1774
         public Object getTree() { return tree; }
 4694  
     };
 4695  
 
 4696  
 
 4697  
     // $ANTLR start "bindingsClause"
 4698  
     // com\\googlecode\\sparkleg\\Sparql.g:176:1: bindingsClause : ( BINDINGS ( var )* OPEN_CURLY_BRACE ( bindingValueList )* CLOSE_CURLY_BRACE )? -> ( ^( BINDINGS ( var )* ( bindingValueList )* ) )? ;
 4699  
     public final SparqlParser.bindingsClause_return bindingsClause() throws RecognitionException {
 4700  1774
         SparqlParser.bindingsClause_return retval = new SparqlParser.bindingsClause_return();
 4701  1774
         retval.start = input.LT(1);
 4702  
 
 4703  
 
 4704  1774
         Object root_0 = null;
 4705  
 
 4706  1774
         Token BINDINGS96=null;
 4707  1774
         Token OPEN_CURLY_BRACE98=null;
 4708  1774
         Token CLOSE_CURLY_BRACE100=null;
 4709  1774
         SparqlParser.var_return var97 =null;
 4710  
 
 4711  1774
         SparqlParser.bindingValueList_return bindingValueList99 =null;
 4712  
 
 4713  
 
 4714  1774
         Object BINDINGS96_tree=null;
 4715  1774
         Object OPEN_CURLY_BRACE98_tree=null;
 4716  1774
         Object CLOSE_CURLY_BRACE100_tree=null;
 4717  1774
         RewriteRuleTokenStream stream_BINDINGS=new RewriteRuleTokenStream(adaptor,"token BINDINGS");
 4718  1774
         RewriteRuleTokenStream stream_OPEN_CURLY_BRACE=new RewriteRuleTokenStream(adaptor,"token OPEN_CURLY_BRACE");
 4719  1774
         RewriteRuleTokenStream stream_CLOSE_CURLY_BRACE=new RewriteRuleTokenStream(adaptor,"token CLOSE_CURLY_BRACE");
 4720  1774
         RewriteRuleSubtreeStream stream_var=new RewriteRuleSubtreeStream(adaptor,"rule var");
 4721  1774
         RewriteRuleSubtreeStream stream_bindingValueList=new RewriteRuleSubtreeStream(adaptor,"rule bindingValueList");
 4722  
         try {
 4723  
             // com\\googlecode\\sparkleg\\Sparql.g:177:5: ( ( BINDINGS ( var )* OPEN_CURLY_BRACE ( bindingValueList )* CLOSE_CURLY_BRACE )? -> ( ^( BINDINGS ( var )* ( bindingValueList )* ) )? )
 4724  
             // com\\googlecode\\sparkleg\\Sparql.g:177:7: ( BINDINGS ( var )* OPEN_CURLY_BRACE ( bindingValueList )* CLOSE_CURLY_BRACE )?
 4725  
             {
 4726  
             // com\\googlecode\\sparkleg\\Sparql.g:177:7: ( BINDINGS ( var )* OPEN_CURLY_BRACE ( bindingValueList )* CLOSE_CURLY_BRACE )?
 4727  1774
             int alt37=2;
 4728  1774
             switch ( input.LA(1) ) {
 4729  
                 case BINDINGS:
 4730  
                     {
 4731  26
                     alt37=1;
 4732  
                     }
 4733  
                     break;
 4734  
             }
 4735  
 
 4736  1774
             switch (alt37) {
 4737  
                 case 1 :
 4738  
                     // com\\googlecode\\sparkleg\\Sparql.g:177:8: BINDINGS ( var )* OPEN_CURLY_BRACE ( bindingValueList )* CLOSE_CURLY_BRACE
 4739  
                     {
 4740  26
                     BINDINGS96=(Token)match(input,BINDINGS,FOLLOW_BINDINGS_in_bindingsClause1212);  
 4741  26
                     stream_BINDINGS.add(BINDINGS96);
 4742  
 
 4743  
 
 4744  
                     // com\\googlecode\\sparkleg\\Sparql.g:177:17: ( var )*
 4745  
                     loop35:
 4746  
                     do {
 4747  64
                         int alt35=2;
 4748  64
                         switch ( input.LA(1) ) {
 4749  
                         case VAR1:
 4750  
                         case VAR2:
 4751  
                             {
 4752  38
                             alt35=1;
 4753  
                             }
 4754  
                             break;
 4755  
 
 4756  
                         }
 4757  
 
 4758  64
                         switch (alt35) {
 4759  
                             case 1 :
 4760  
                                 // com\\googlecode\\sparkleg\\Sparql.g:177:17: var
 4761  
                                 {
 4762  38
                                 pushFollow(FOLLOW_var_in_bindingsClause1214);
 4763  38
                                 var97=var();
 4764  
 
 4765  38
                                 state._fsp--;
 4766  
 
 4767  38
                                 stream_var.add(var97.getTree());
 4768  
 
 4769  
                                 }
 4770  38
                                 break;
 4771  
 
 4772  
                             default :
 4773  26
                                 break loop35;
 4774  
                         }
 4775  38
                     } while (true);
 4776  
 
 4777  
 
 4778  26
                     OPEN_CURLY_BRACE98=(Token)match(input,OPEN_CURLY_BRACE,FOLLOW_OPEN_CURLY_BRACE_in_bindingsClause1217);  
 4779  26
                     stream_OPEN_CURLY_BRACE.add(OPEN_CURLY_BRACE98);
 4780  
 
 4781  
 
 4782  
                     // com\\googlecode\\sparkleg\\Sparql.g:177:39: ( bindingValueList )*
 4783  
                     loop36:
 4784  
                     do {
 4785  60
                         int alt36=2;
 4786  60
                         switch ( input.LA(1) ) {
 4787  
                         case OPEN_BRACE:
 4788  
                             {
 4789  34
                             alt36=1;
 4790  
                             }
 4791  
                             break;
 4792  
 
 4793  
                         }
 4794  
 
 4795  60
                         switch (alt36) {
 4796  
                             case 1 :
 4797  
                                 // com\\googlecode\\sparkleg\\Sparql.g:177:39: bindingValueList
 4798  
                                 {
 4799  34
                                 pushFollow(FOLLOW_bindingValueList_in_bindingsClause1219);
 4800  34
                                 bindingValueList99=bindingValueList();
 4801  
 
 4802  34
                                 state._fsp--;
 4803  
 
 4804  34
                                 stream_bindingValueList.add(bindingValueList99.getTree());
 4805  
 
 4806  
                                 }
 4807  34
                                 break;
 4808  
 
 4809  
                             default :
 4810  26
                                 break loop36;
 4811  
                         }
 4812  34
                     } while (true);
 4813  
 
 4814  
 
 4815  26
                     CLOSE_CURLY_BRACE100=(Token)match(input,CLOSE_CURLY_BRACE,FOLLOW_CLOSE_CURLY_BRACE_in_bindingsClause1222);  
 4816  26
                     stream_CLOSE_CURLY_BRACE.add(CLOSE_CURLY_BRACE100);
 4817  
 
 4818  
 
 4819  
                     }
 4820  
                     break;
 4821  
 
 4822  
             }
 4823  
 
 4824  
 
 4825  
             // AST REWRITE
 4826  
             // elements: var, BINDINGS, bindingValueList
 4827  
             // token labels: 
 4828  
             // rule labels: retval
 4829  
             // token list labels: 
 4830  
             // rule list labels: 
 4831  
             // wildcard labels: 
 4832  1774
             retval.tree = root_0;
 4833  1774
             RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 4834  
 
 4835  1774
             root_0 = (Object)adaptor.nil();
 4836  
             // 177:77: -> ( ^( BINDINGS ( var )* ( bindingValueList )* ) )?
 4837  
             {
 4838  
                 // com\\googlecode\\sparkleg\\Sparql.g:177:80: ( ^( BINDINGS ( var )* ( bindingValueList )* ) )?
 4839  1774
                 if ( stream_var.hasNext()||stream_BINDINGS.hasNext()||stream_bindingValueList.hasNext() ) {
 4840  
                     // com\\googlecode\\sparkleg\\Sparql.g:177:80: ^( BINDINGS ( var )* ( bindingValueList )* )
 4841  
                     {
 4842  26
                     Object root_1 = (Object)adaptor.nil();
 4843  26
                     root_1 = (Object)adaptor.becomeRoot(
 4844  
                     stream_BINDINGS.nextNode()
 4845  
                     , root_1);
 4846  
 
 4847  
                     // com\\googlecode\\sparkleg\\Sparql.g:177:91: ( var )*
 4848  64
                     while ( stream_var.hasNext() ) {
 4849  38
                         adaptor.addChild(root_1, stream_var.nextTree());
 4850  
 
 4851  
                     }
 4852  26
                     stream_var.reset();
 4853  
 
 4854  
                     // com\\googlecode\\sparkleg\\Sparql.g:177:96: ( bindingValueList )*
 4855  60
                     while ( stream_bindingValueList.hasNext() ) {
 4856  34
                         adaptor.addChild(root_1, stream_bindingValueList.nextTree());
 4857  
 
 4858  
                     }
 4859  26
                     stream_bindingValueList.reset();
 4860  
 
 4861  26
                     adaptor.addChild(root_0, root_1);
 4862  
                     }
 4863  
 
 4864  
                 }
 4865  1774
                 stream_var.reset();
 4866  1774
                 stream_BINDINGS.reset();
 4867  1774
                 stream_bindingValueList.reset();
 4868  
 
 4869  
             }
 4870  
 
 4871  
 
 4872  1774
             retval.tree = root_0;
 4873  
 
 4874  
             }
 4875  
 
 4876  1774
             retval.stop = input.LT(-1);
 4877  
 
 4878  
 
 4879  1774
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 4880  1774
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 4881  
 
 4882  
         }
 4883  0
         catch (RecognitionException re) {
 4884  0
             reportError(re);
 4885  0
             recover(input,re);
 4886  0
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 4887  
 
 4888  
         }
 4889  
 
 4890  0
         finally {
 4891  
                 // do for sure before leaving
 4892  1774
         }
 4893  1774
         return retval;
 4894  
     }
 4895  
     // $ANTLR end "bindingsClause"
 4896  
 
 4897  
 
 4898  34
     public static class bindingValueList_return extends ParserRuleReturnScope {
 4899  
         Object tree;
 4900  34
         public Object getTree() { return tree; }
 4901  
     };
 4902  
 
 4903  
 
 4904  
     // $ANTLR start "bindingValueList"
 4905  
     // com\\googlecode\\sparkleg\\Sparql.g:180:1: bindingValueList : OPEN_BRACE ( bindingValue )* CLOSE_BRACE -> ^( BINDING_VALUE ( bindingValue )* ) ;
 4906  
     public final SparqlParser.bindingValueList_return bindingValueList() throws RecognitionException {
 4907  34
         SparqlParser.bindingValueList_return retval = new SparqlParser.bindingValueList_return();
 4908  34
         retval.start = input.LT(1);
 4909  
 
 4910  
 
 4911  34
         Object root_0 = null;
 4912  
 
 4913  34
         Token OPEN_BRACE101=null;
 4914  34
         Token CLOSE_BRACE103=null;
 4915  34
         SparqlParser.bindingValue_return bindingValue102 =null;
 4916  
 
 4917  
 
 4918  34
         Object OPEN_BRACE101_tree=null;
 4919  34
         Object CLOSE_BRACE103_tree=null;
 4920  34
         RewriteRuleTokenStream stream_CLOSE_BRACE=new RewriteRuleTokenStream(adaptor,"token CLOSE_BRACE");
 4921  34
         RewriteRuleTokenStream stream_OPEN_BRACE=new RewriteRuleTokenStream(adaptor,"token OPEN_BRACE");
 4922  34
         RewriteRuleSubtreeStream stream_bindingValue=new RewriteRuleSubtreeStream(adaptor,"rule bindingValue");
 4923  
         try {
 4924  
             // com\\googlecode\\sparkleg\\Sparql.g:181:5: ( OPEN_BRACE ( bindingValue )* CLOSE_BRACE -> ^( BINDING_VALUE ( bindingValue )* ) )
 4925  
             // com\\googlecode\\sparkleg\\Sparql.g:181:7: OPEN_BRACE ( bindingValue )* CLOSE_BRACE
 4926  
             {
 4927  34
             OPEN_BRACE101=(Token)match(input,OPEN_BRACE,FOLLOW_OPEN_BRACE_in_bindingValueList1258);  
 4928  34
             stream_OPEN_BRACE.add(OPEN_BRACE101);
 4929  
 
 4930  
 
 4931  
             // com\\googlecode\\sparkleg\\Sparql.g:181:18: ( bindingValue )*
 4932  
             loop38:
 4933  
             do {
 4934  88
                 int alt38=2;
 4935  88
                 switch ( input.LA(1) ) {
 4936  
                 case DECIMAL:
 4937  
                 case DECIMAL_NEGATIVE:
 4938  
                 case DECIMAL_POSITIVE:
 4939  
                 case DOUBLE:
 4940  
                 case DOUBLE_NEGATIVE:
 4941  
                 case DOUBLE_POSITIVE:
 4942  
                 case FALSE:
 4943  
                 case INTEGER:
 4944  
                 case INTEGER_NEGATIVE:
 4945  
                 case INTEGER_POSITIVE:
 4946  
                 case IRI_REF:
 4947  
                 case PNAME_LN:
 4948  
                 case PNAME_NS:
 4949  
                 case STRING_LITERAL1:
 4950  
                 case STRING_LITERAL2:
 4951  
                 case STRING_LITERAL_LONG1:
 4952  
                 case STRING_LITERAL_LONG2:
 4953  
                 case TRUE:
 4954  
                 case UNDEF:
 4955  
                     {
 4956  54
                     alt38=1;
 4957  
                     }
 4958  
                     break;
 4959  
 
 4960  
                 }
 4961  
 
 4962  88
                 switch (alt38) {
 4963  
                     case 1 :
 4964  
                         // com\\googlecode\\sparkleg\\Sparql.g:181:18: bindingValue
 4965  
                         {
 4966  54
                         pushFollow(FOLLOW_bindingValue_in_bindingValueList1260);
 4967  54
                         bindingValue102=bindingValue();
 4968  
 
 4969  54
                         state._fsp--;
 4970  
 
 4971  54
                         stream_bindingValue.add(bindingValue102.getTree());
 4972  
 
 4973  
                         }
 4974  54
                         break;
 4975  
 
 4976  
                     default :
 4977  34
                         break loop38;
 4978  
                 }
 4979  54
             } while (true);
 4980  
 
 4981  
 
 4982  34
             CLOSE_BRACE103=(Token)match(input,CLOSE_BRACE,FOLLOW_CLOSE_BRACE_in_bindingValueList1263);  
 4983  34
             stream_CLOSE_BRACE.add(CLOSE_BRACE103);
 4984  
 
 4985  
 
 4986  
             // AST REWRITE
 4987  
             // elements: bindingValue
 4988  
             // token labels: 
 4989  
             // rule labels: retval
 4990  
             // token list labels: 
 4991  
             // rule list labels: 
 4992  
             // wildcard labels: 
 4993  34
             retval.tree = root_0;
 4994  34
             RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 4995  
 
 4996  34
             root_0 = (Object)adaptor.nil();
 4997  
             // 181:44: -> ^( BINDING_VALUE ( bindingValue )* )
 4998  
             {
 4999  
                 // com\\googlecode\\sparkleg\\Sparql.g:181:47: ^( BINDING_VALUE ( bindingValue )* )
 5000  
                 {
 5001  34
                 Object root_1 = (Object)adaptor.nil();
 5002  34
                 root_1 = (Object)adaptor.becomeRoot(
 5003  
                 (Object)adaptor.create(BINDING_VALUE, "BINDING_VALUE")
 5004  
                 , root_1);
 5005  
 
 5006  
                 // com\\googlecode\\sparkleg\\Sparql.g:181:63: ( bindingValue )*
 5007  88
                 while ( stream_bindingValue.hasNext() ) {
 5008  54
                     adaptor.addChild(root_1, stream_bindingValue.nextTree());
 5009  
 
 5010  
                 }
 5011  34
                 stream_bindingValue.reset();
 5012  
 
 5013  34
                 adaptor.addChild(root_0, root_1);
 5014  
                 }
 5015  
 
 5016  
             }
 5017  
 
 5018  
 
 5019  34
             retval.tree = root_0;
 5020  
 
 5021  
             }
 5022  
 
 5023  34
             retval.stop = input.LT(-1);
 5024  
 
 5025  
 
 5026  34
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 5027  34
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 5028  
 
 5029  
         }
 5030  0
         catch (RecognitionException re) {
 5031  0
             reportError(re);
 5032  0
             recover(input,re);
 5033  0
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 5034  
 
 5035  
         }
 5036  
 
 5037  0
         finally {
 5038  
                 // do for sure before leaving
 5039  34
         }
 5040  34
         return retval;
 5041  
     }
 5042  
     // $ANTLR end "bindingValueList"
 5043  
 
 5044  
 
 5045  54
     public static class bindingValue_return extends ParserRuleReturnScope {
 5046  
         Object tree;
 5047  54
         public Object getTree() { return tree; }
 5048  
     };
 5049  
 
 5050  
 
 5051  
     // $ANTLR start "bindingValue"
 5052  
     // com\\googlecode\\sparkleg\\Sparql.g:184:1: bindingValue : ( iriRef | rdfLiteral | numericLiteral | booleanLiteral | UNDEF );
 5053  
     public final SparqlParser.bindingValue_return bindingValue() throws RecognitionException {
 5054  54
         SparqlParser.bindingValue_return retval = new SparqlParser.bindingValue_return();
 5055  54
         retval.start = input.LT(1);
 5056  
 
 5057  
 
 5058  54
         Object root_0 = null;
 5059  
 
 5060  54
         Token UNDEF108=null;
 5061  54
         SparqlParser.iriRef_return iriRef104 =null;
 5062  
 
 5063  54
         SparqlParser.rdfLiteral_return rdfLiteral105 =null;
 5064  
 
 5065  54
         SparqlParser.numericLiteral_return numericLiteral106 =null;
 5066  
 
 5067  54
         SparqlParser.booleanLiteral_return booleanLiteral107 =null;
 5068  
 
 5069  
 
 5070  54
         Object UNDEF108_tree=null;
 5071  
 
 5072  
         try {
 5073  
             // com\\googlecode\\sparkleg\\Sparql.g:185:5: ( iriRef | rdfLiteral | numericLiteral | booleanLiteral | UNDEF )
 5074  54
             int alt39=5;
 5075  54
             switch ( input.LA(1) ) {
 5076  
             case IRI_REF:
 5077  
             case PNAME_LN:
 5078  
             case PNAME_NS:
 5079  
                 {
 5080  22
                 alt39=1;
 5081  
                 }
 5082  22
                 break;
 5083  
             case STRING_LITERAL1:
 5084  
             case STRING_LITERAL2:
 5085  
             case STRING_LITERAL_LONG1:
 5086  
             case STRING_LITERAL_LONG2:
 5087  
                 {
 5088  14
                 alt39=2;
 5089  
                 }
 5090  14
                 break;
 5091  
             case DECIMAL:
 5092  
             case DECIMAL_NEGATIVE:
 5093  
             case DECIMAL_POSITIVE:
 5094  
             case DOUBLE:
 5095  
             case DOUBLE_NEGATIVE:
 5096  
             case DOUBLE_POSITIVE:
 5097  
             case INTEGER:
 5098  
             case INTEGER_NEGATIVE:
 5099  
             case INTEGER_POSITIVE:
 5100  
                 {
 5101  0
                 alt39=3;
 5102  
                 }
 5103  0
                 break;
 5104  
             case FALSE:
 5105  
             case TRUE:
 5106  
                 {
 5107  0
                 alt39=4;
 5108  
                 }
 5109  0
                 break;
 5110  
             case UNDEF:
 5111  
                 {
 5112  18
                 alt39=5;
 5113  
                 }
 5114  18
                 break;
 5115  
             default:
 5116  0
                 NoViableAltException nvae =
 5117  
                     new NoViableAltException("", 39, 0, input);
 5118  
 
 5119  0
                 throw nvae;
 5120  
 
 5121  
             }
 5122  
 
 5123  54
             switch (alt39) {
 5124  
                 case 1 :
 5125  
                     // com\\googlecode\\sparkleg\\Sparql.g:185:7: iriRef
 5126  
                     {
 5127  22
                     root_0 = (Object)adaptor.nil();
 5128  
 
 5129  
 
 5130  22
                     pushFollow(FOLLOW_iriRef_in_bindingValue1294);
 5131  22
                     iriRef104=iriRef();
 5132  
 
 5133  22
                     state._fsp--;
 5134  
 
 5135  22
                     adaptor.addChild(root_0, iriRef104.getTree());
 5136  
 
 5137  
                     }
 5138  22
                     break;
 5139  
                 case 2 :
 5140  
                     // com\\googlecode\\sparkleg\\Sparql.g:185:16: rdfLiteral
 5141  
                     {
 5142  14
                     root_0 = (Object)adaptor.nil();
 5143  
 
 5144  
 
 5145  14
                     pushFollow(FOLLOW_rdfLiteral_in_bindingValue1298);
 5146  14
                     rdfLiteral105=rdfLiteral();
 5147  
 
 5148  14
                     state._fsp--;
 5149  
 
 5150  14
                     adaptor.addChild(root_0, rdfLiteral105.getTree());
 5151  
 
 5152  
                     }
 5153  14
                     break;
 5154  
                 case 3 :
 5155  
                     // com\\googlecode\\sparkleg\\Sparql.g:185:29: numericLiteral
 5156  
                     {
 5157  0
                     root_0 = (Object)adaptor.nil();
 5158  
 
 5159  
 
 5160  0
                     pushFollow(FOLLOW_numericLiteral_in_bindingValue1302);
 5161  0
                     numericLiteral106=numericLiteral();
 5162  
 
 5163  0
                     state._fsp--;
 5164  
 
 5165  0
                     adaptor.addChild(root_0, numericLiteral106.getTree());
 5166  
 
 5167  
                     }
 5168  0
                     break;
 5169  
                 case 4 :
 5170  
                     // com\\googlecode\\sparkleg\\Sparql.g:185:46: booleanLiteral
 5171  
                     {
 5172  0
                     root_0 = (Object)adaptor.nil();
 5173  
 
 5174  
 
 5175  0
                     pushFollow(FOLLOW_booleanLiteral_in_bindingValue1306);
 5176  0
                     booleanLiteral107=booleanLiteral();
 5177  
 
 5178  0
                     state._fsp--;
 5179  
 
 5180  0
                     adaptor.addChild(root_0, booleanLiteral107.getTree());
 5181  
 
 5182  
                     }
 5183  0
                     break;
 5184  
                 case 5 :
 5185  
                     // com\\googlecode\\sparkleg\\Sparql.g:185:63: UNDEF
 5186  
                     {
 5187  18
                     root_0 = (Object)adaptor.nil();
 5188  
 
 5189  
 
 5190  18
                     UNDEF108=(Token)match(input,UNDEF,FOLLOW_UNDEF_in_bindingValue1310); 
 5191  18
                     UNDEF108_tree = 
 5192  
                     (Object)adaptor.create(UNDEF108)
 5193  
                     ;
 5194  18
                     adaptor.addChild(root_0, UNDEF108_tree);
 5195  
 
 5196  
 
 5197  
                     }
 5198  
                     break;
 5199  
 
 5200  
             }
 5201  54
             retval.stop = input.LT(-1);
 5202  
 
 5203  
 
 5204  54
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 5205  54
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 5206  
 
 5207  
         }
 5208  0
         catch (RecognitionException re) {
 5209  0
             reportError(re);
 5210  0
             recover(input,re);
 5211  0
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 5212  
 
 5213  
         }
 5214  
 
 5215  0
         finally {
 5216  
                 // do for sure before leaving
 5217  54
         }
 5218  54
         return retval;
 5219  
     }
 5220  
     // $ANTLR end "bindingValue"
 5221  
 
 5222  
 
 5223  128
     public static class update_return extends ParserRuleReturnScope {
 5224  
         Object tree;
 5225  128
         public Object getTree() { return tree; }
 5226  
     };
 5227  
 
 5228  
 
 5229  
     // $ANTLR start "update"
 5230  
     // com\\googlecode\\sparkleg\\Sparql.g:188:1: update : prologue ( load | clear | drop | add | move | copy | create | insert | delete | modify ) -> prologue ( load )* ( clear )* ( drop )* ( add )* ( move )* ( copy )* ( create )* ( insert )* ( delete )* ( modify )* ;
 5231  
     public final SparqlParser.update_return update() throws RecognitionException {
 5232  128
         SparqlParser.update_return retval = new SparqlParser.update_return();
 5233  128
         retval.start = input.LT(1);
 5234  
 
 5235  
 
 5236  128
         Object root_0 = null;
 5237  
 
 5238  128
         SparqlParser.prologue_return prologue109 =null;
 5239  
 
 5240  128
         SparqlParser.load_return load110 =null;
 5241  
 
 5242  128
         SparqlParser.clear_return clear111 =null;
 5243  
 
 5244  128
         SparqlParser.drop_return drop112 =null;
 5245  
 
 5246  128
         SparqlParser.add_return add113 =null;
 5247  
 
 5248  128
         SparqlParser.move_return move114 =null;
 5249  
 
 5250  128
         SparqlParser.copy_return copy115 =null;
 5251  
 
 5252  128
         SparqlParser.create_return create116 =null;
 5253  
 
 5254  128
         SparqlParser.insert_return insert117 =null;
 5255  
 
 5256  128
         SparqlParser.delete_return delete118 =null;
 5257  
 
 5258  128
         SparqlParser.modify_return modify119 =null;
 5259  
 
 5260  
 
 5261  128
         RewriteRuleSubtreeStream stream_clear=new RewriteRuleSubtreeStream(adaptor,"rule clear");
 5262  128
         RewriteRuleSubtreeStream stream_prologue=new RewriteRuleSubtreeStream(adaptor,"rule prologue");
 5263  128
         RewriteRuleSubtreeStream stream_drop=new RewriteRuleSubtreeStream(adaptor,"rule drop");
 5264  128
         RewriteRuleSubtreeStream stream_delete=new RewriteRuleSubtreeStream(adaptor,"rule delete");
 5265  128
         RewriteRuleSubtreeStream stream_modify=new RewriteRuleSubtreeStream(adaptor,"rule modify");
 5266  128
         RewriteRuleSubtreeStream stream_load=new RewriteRuleSubtreeStream(adaptor,"rule load");
 5267  128
         RewriteRuleSubtreeStream stream_add=new RewriteRuleSubtreeStream(adaptor,"rule add");
 5268  128
         RewriteRuleSubtreeStream stream_insert=new RewriteRuleSubtreeStream(adaptor,"rule insert");
 5269  128
         RewriteRuleSubtreeStream stream_create=new RewriteRuleSubtreeStream(adaptor,"rule create");
 5270  128
         RewriteRuleSubtreeStream stream_move=new RewriteRuleSubtreeStream(adaptor,"rule move");
 5271  128
         RewriteRuleSubtreeStream stream_copy=new RewriteRuleSubtreeStream(adaptor,"rule copy");
 5272  
         try {
 5273  
             // com\\googlecode\\sparkleg\\Sparql.g:189:5: ( prologue ( load | clear | drop | add | move | copy | create | insert | delete | modify ) -> prologue ( load )* ( clear )* ( drop )* ( add )* ( move )* ( copy )* ( create )* ( insert )* ( delete )* ( modify )* )
 5274  
             // com\\googlecode\\sparkleg\\Sparql.g:189:7: prologue ( load | clear | drop | add | move | copy | create | insert | delete | modify )
 5275  
             {
 5276  128
             pushFollow(FOLLOW_prologue_in_update1331);
 5277  128
             prologue109=prologue();
 5278  
 
 5279  128
             state._fsp--;
 5280  
 
 5281  128
             stream_prologue.add(prologue109.getTree());
 5282  
 
 5283  
             // com\\googlecode\\sparkleg\\Sparql.g:189:16: ( load | clear | drop | add | move | copy | create | insert | delete | modify )
 5284  128
             int alt40=10;
 5285  128
             switch ( input.LA(1) ) {
 5286  
             case LOAD:
 5287  
                 {
 5288  0
                 alt40=1;
 5289  
                 }
 5290  0
                 break;
 5291  
             case CLEAR:
 5292  
                 {
 5293  8
                 alt40=2;
 5294  
                 }
 5295  8
                 break;
 5296  
             case DROP:
 5297  
                 {
 5298  8
                 alt40=3;
 5299  
                 }
 5300  8
                 break;
 5301  
             case ADD:
 5302  
                 {
 5303  0
                 alt40=4;
 5304  
                 }
 5305  0
                 break;
 5306  
             case MOVE:
 5307  
                 {
 5308  0
                 alt40=5;
 5309  
                 }
 5310  0
                 break;
 5311  
             case COPY:
 5312  
                 {
 5313  0
                 alt40=6;
 5314  
                 }
 5315  0
                 break;
 5316  
             case CREATE:
 5317  
                 {
 5318  0
                 alt40=7;
 5319  
                 }
 5320  0
                 break;
 5321  
             case INSERT:
 5322  
                 {
 5323  20
                 switch ( input.LA(2) ) {
 5324  
                 case DATA:
 5325  
                     {
 5326  8
                     alt40=8;
 5327  
                     }
 5328  8
                     break;
 5329  
                 case OPEN_CURLY_BRACE:
 5330  
                     {
 5331  12
                     alt40=10;
 5332  
                     }
 5333  12
                     break;
 5334  
                 default:
 5335  0
                     NoViableAltException nvae =
 5336  
                         new NoViableAltException("", 40, 8, input);
 5337  
 
 5338  0
                     throw nvae;
 5339  
 
 5340  
                 }
 5341  
 
 5342  
                 }
 5343  20
                 break;
 5344  
             case DELETE:
 5345  
                 {
 5346  78
                 switch ( input.LA(2) ) {
 5347  
                 case DATA:
 5348  
                 case WHERE:
 5349  
                     {
 5350  24
                     alt40=9;
 5351  
                     }
 5352  24
                     break;
 5353  
                 case OPEN_CURLY_BRACE:
 5354  
                     {
 5355  54
                     alt40=10;
 5356  
                     }
 5357  54
                     break;
 5358  
                 default:
 5359  0
                     NoViableAltException nvae =
 5360  
                         new NoViableAltException("", 40, 9, input);
 5361  
 
 5362  0
                     throw nvae;
 5363  
 
 5364  
                 }
 5365  
 
 5366  
                 }
 5367  78
                 break;
 5368  
             case WITH:
 5369  
                 {
 5370  14
                 alt40=10;
 5371  
                 }
 5372  14
                 break;
 5373  
             default:
 5374  0
                 NoViableAltException nvae =
 5375  
                     new NoViableAltException("", 40, 0, input);
 5376  
 
 5377  0
                 throw nvae;
 5378  
 
 5379  
             }
 5380  
 
 5381  128
             switch (alt40) {
 5382  
                 case 1 :
 5383  
                     // com\\googlecode\\sparkleg\\Sparql.g:189:17: load
 5384  
                     {
 5385  0
                     pushFollow(FOLLOW_load_in_update1334);
 5386  0
                     load110=load();
 5387  
 
 5388  0
                     state._fsp--;
 5389  
 
 5390  0
                     stream_load.add(load110.getTree());
 5391  
 
 5392  
                     }
 5393  0
                     break;
 5394  
                 case 2 :
 5395  
                     // com\\googlecode\\sparkleg\\Sparql.g:189:24: clear
 5396  
                     {
 5397  8
                     pushFollow(FOLLOW_clear_in_update1338);
 5398  8
                     clear111=clear();
 5399  
 
 5400  8
                     state._fsp--;
 5401  
 
 5402  8
                     stream_clear.add(clear111.getTree());
 5403  
 
 5404  
                     }
 5405  8
                     break;
 5406  
                 case 3 :
 5407  
                     // com\\googlecode\\sparkleg\\Sparql.g:189:32: drop
 5408  
                     {
 5409  8
                     pushFollow(FOLLOW_drop_in_update1342);
 5410  8
                     drop112=drop();
 5411  
 
 5412  8
                     state._fsp--;
 5413  
 
 5414  8
                     stream_drop.add(drop112.getTree());
 5415  
 
 5416  
                     }
 5417  8
                     break;
 5418  
                 case 4 :
 5419  
                     // com\\googlecode\\sparkleg\\Sparql.g:189:39: add
 5420  
                     {
 5421  0
                     pushFollow(FOLLOW_add_in_update1346);
 5422  0
                     add113=add();
 5423  
 
 5424  0
                     state._fsp--;
 5425  
 
 5426  0
                     stream_add.add(add113.getTree());
 5427  
 
 5428  
                     }
 5429  0
                     break;
 5430  
                 case 5 :
 5431  
                     // com\\googlecode\\sparkleg\\Sparql.g:189:45: move
 5432  
                     {
 5433  0
                     pushFollow(FOLLOW_move_in_update1350);
 5434  0
                     move114=move();
 5435  
 
 5436  0
                     state._fsp--;
 5437  
 
 5438  0
                     stream_move.add(move114.getTree());
 5439  
 
 5440  
                     }
 5441  0
                     break;
 5442  
                 case 6 :
 5443  
                     // com\\googlecode\\sparkleg\\Sparql.g:189:52: copy
 5444  
                     {
 5445  0
                     pushFollow(FOLLOW_copy_in_update1354);
 5446  0
                     copy115=copy();
 5447  
 
 5448  0
                     state._fsp--;
 5449  
 
 5450  0
                     stream_copy.add(copy115.getTree());
 5451  
 
 5452  
                     }
 5453  0
                     break;
 5454  
                 case 7 :
 5455  
                     // com\\googlecode\\sparkleg\\Sparql.g:189:59: create
 5456  
                     {
 5457  0
                     pushFollow(FOLLOW_create_in_update1358);
 5458  0
                     create116=create();
 5459  
 
 5460  0
                     state._fsp--;
 5461  
 
 5462  0
                     stream_create.add(create116.getTree());
 5463  
 
 5464  
                     }
 5465  0
                     break;
 5466  
                 case 8 :
 5467  
                     // com\\googlecode\\sparkleg\\Sparql.g:189:68: insert
 5468  
                     {
 5469  8
                     pushFollow(FOLLOW_insert_in_update1362);
 5470  8
                     insert117=insert();
 5471  
 
 5472  8
                     state._fsp--;
 5473  
 
 5474  8
                     stream_insert.add(insert117.getTree());
 5475  
 
 5476  
                     }
 5477  8
                     break;
 5478  
                 case 9 :
 5479  
                     // com\\googlecode\\sparkleg\\Sparql.g:189:77: delete
 5480  
                     {
 5481  24
                     pushFollow(FOLLOW_delete_in_update1366);
 5482  24
                     delete118=delete();
 5483  
 
 5484  24
                     state._fsp--;
 5485  
 
 5486  24
                     stream_delete.add(delete118.getTree());
 5487  
 
 5488  
                     }
 5489  24
                     break;
 5490  
                 case 10 :
 5491  
                     // com\\googlecode\\sparkleg\\Sparql.g:189:86: modify
 5492  
                     {
 5493  80
                     pushFollow(FOLLOW_modify_in_update1370);
 5494  80
                     modify119=modify();
 5495  
 
 5496  80
                     state._fsp--;
 5497  
 
 5498  80
                     stream_modify.add(modify119.getTree());
 5499  
 
 5500  
                     }
 5501  
                     break;
 5502  
 
 5503  
             }
 5504  
 
 5505  
 
 5506  
             // AST REWRITE
 5507  
             // elements: clear, modify, move, drop, prologue, delete, load, copy, create, add, insert
 5508  
             // token labels: 
 5509  
             // rule labels: retval
 5510  
             // token list labels: 
 5511  
             // rule list labels: 
 5512  
             // wildcard labels: 
 5513  128
             retval.tree = root_0;
 5514  128
             RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 5515  
 
 5516  128
             root_0 = (Object)adaptor.nil();
 5517  
             // 189:94: -> prologue ( load )* ( clear )* ( drop )* ( add )* ( move )* ( copy )* ( create )* ( insert )* ( delete )* ( modify )*
 5518  
             {
 5519  128
                 adaptor.addChild(root_0, stream_prologue.nextTree());
 5520  
 
 5521  
                 // com\\googlecode\\sparkleg\\Sparql.g:189:106: ( load )*
 5522  128
                 while ( stream_load.hasNext() ) {
 5523  0
                     adaptor.addChild(root_0, stream_load.nextTree());
 5524  
 
 5525  
                 }
 5526  128
                 stream_load.reset();
 5527  
 
 5528  
                 // com\\googlecode\\sparkleg\\Sparql.g:189:112: ( clear )*
 5529  136
                 while ( stream_clear.hasNext() ) {
 5530  8
                     adaptor.addChild(root_0, stream_clear.nextTree());
 5531  
 
 5532  
                 }
 5533  128
                 stream_clear.reset();
 5534  
 
 5535  
                 // com\\googlecode\\sparkleg\\Sparql.g:189:119: ( drop )*
 5536  136
                 while ( stream_drop.hasNext() ) {
 5537  8
                     adaptor.addChild(root_0, stream_drop.nextTree());
 5538  
 
 5539  
                 }
 5540  128
                 stream_drop.reset();
 5541  
 
 5542  
                 // com\\googlecode\\sparkleg\\Sparql.g:189:125: ( add )*
 5543  128
                 while ( stream_add.hasNext() ) {
 5544  0
                     adaptor.addChild(root_0, stream_add.nextTree());
 5545  
 
 5546  
                 }
 5547  128
                 stream_add.reset();
 5548  
 
 5549  
                 // com\\googlecode\\sparkleg\\Sparql.g:189:130: ( move )*
 5550  128
                 while ( stream_move.hasNext() ) {
 5551  0
                     adaptor.addChild(root_0, stream_move.nextTree());
 5552  
 
 5553  
                 }
 5554  128
                 stream_move.reset();
 5555  
 
 5556  
                 // com\\googlecode\\sparkleg\\Sparql.g:189:136: ( copy )*
 5557  128
                 while ( stream_copy.hasNext() ) {
 5558  0
                     adaptor.addChild(root_0, stream_copy.nextTree());
 5559  
 
 5560  
                 }
 5561  128
                 stream_copy.reset();
 5562  
 
 5563  
                 // com\\googlecode\\sparkleg\\Sparql.g:189:142: ( create )*
 5564  128
                 while ( stream_create.hasNext() ) {
 5565  0
                     adaptor.addChild(root_0, stream_create.nextTree());
 5566  
 
 5567  
                 }
 5568  128
                 stream_create.reset();
 5569  
 
 5570  
                 // com\\googlecode\\sparkleg\\Sparql.g:189:150: ( insert )*
 5571  136
                 while ( stream_insert.hasNext() ) {
 5572  8
                     adaptor.addChild(root_0, stream_insert.nextTree());
 5573  
 
 5574  
                 }
 5575  128
                 stream_insert.reset();
 5576  
 
 5577  
                 // com\\googlecode\\sparkleg\\Sparql.g:189:158: ( delete )*
 5578  152
                 while ( stream_delete.hasNext() ) {
 5579  24
                     adaptor.addChild(root_0, stream_delete.nextTree());
 5580  
 
 5581  
                 }
 5582  128
                 stream_delete.reset();
 5583  
 
 5584  
                 // com\\googlecode\\sparkleg\\Sparql.g:189:166: ( modify )*
 5585  208
                 while ( stream_modify.hasNext() ) {
 5586  80
                     adaptor.addChild(root_0, stream_modify.nextTree());
 5587  
 
 5588  
                 }
 5589  128
                 stream_modify.reset();
 5590  
 
 5591  
             }
 5592  
 
 5593  
 
 5594  128
             retval.tree = root_0;
 5595  
 
 5596  
             }
 5597  
 
 5598  128
             retval.stop = input.LT(-1);
 5599  
 
 5600  
 
 5601  128
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 5602  128
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 5603  
 
 5604  
         }
 5605  0
         catch (RecognitionException re) {
 5606  0
             reportError(re);
 5607  0
             recover(input,re);
 5608  0
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 5609  
 
 5610  
         }
 5611  
 
 5612  0
         finally {
 5613  
                 // do for sure before leaving
 5614  128
         }
 5615  128
         return retval;
 5616  
     }
 5617  
     // $ANTLR end "update"
 5618  
 
 5619  
 
 5620  0
     public static class load_return extends ParserRuleReturnScope {
 5621  
         Object tree;
 5622  0
         public Object getTree() { return tree; }
 5623  
     };
 5624  
 
 5625  
 
 5626  
     // $ANTLR start "load"
 5627  
     // com\\googlecode\\sparkleg\\Sparql.g:192:1: load : LOAD ( SILENT )? iriRef ( INTO graphRef )? -> ^( LOAD ( SILENT )* iriRef ( graphRef )? ) ;
 5628  
     public final SparqlParser.load_return load() throws RecognitionException {
 5629  0
         SparqlParser.load_return retval = new SparqlParser.load_return();
 5630  0
         retval.start = input.LT(1);
 5631  
 
 5632  
 
 5633  0
         Object root_0 = null;
 5634  
 
 5635  0
         Token LOAD120=null;
 5636  0
         Token SILENT121=null;
 5637  0
         Token INTO123=null;
 5638  0
         SparqlParser.iriRef_return iriRef122 =null;
 5639  
 
 5640  0
         SparqlParser.graphRef_return graphRef124 =null;
 5641  
 
 5642  
 
 5643  0
         Object LOAD120_tree=null;
 5644  0
         Object SILENT121_tree=null;
 5645  0
         Object INTO123_tree=null;
 5646  0
         RewriteRuleTokenStream stream_SILENT=new RewriteRuleTokenStream(adaptor,"token SILENT");
 5647  0
         RewriteRuleTokenStream stream_INTO=new RewriteRuleTokenStream(adaptor,"token INTO");
 5648  0
         RewriteRuleTokenStream stream_LOAD=new RewriteRuleTokenStream(adaptor,"token LOAD");
 5649  0
         RewriteRuleSubtreeStream stream_graphRef=new RewriteRuleSubtreeStream(adaptor,"rule graphRef");
 5650  0
         RewriteRuleSubtreeStream stream_iriRef=new RewriteRuleSubtreeStream(adaptor,"rule iriRef");
 5651  
         try {
 5652  
             // com\\googlecode\\sparkleg\\Sparql.g:193:5: ( LOAD ( SILENT )? iriRef ( INTO graphRef )? -> ^( LOAD ( SILENT )* iriRef ( graphRef )? ) )
 5653  
             // com\\googlecode\\sparkleg\\Sparql.g:193:7: LOAD ( SILENT )? iriRef ( INTO graphRef )?
 5654  
             {
 5655  0
             LOAD120=(Token)match(input,LOAD,FOLLOW_LOAD_in_load1433);  
 5656  0
             stream_LOAD.add(LOAD120);
 5657  
 
 5658  
 
 5659  
             // com\\googlecode\\sparkleg\\Sparql.g:193:12: ( SILENT )?
 5660  0
             int alt41=2;
 5661  0
             switch ( input.LA(1) ) {
 5662  
                 case SILENT:
 5663  
                     {
 5664  0
                     alt41=1;
 5665  
                     }
 5666  
                     break;
 5667  
             }
 5668  
 
 5669  0
             switch (alt41) {
 5670  
                 case 1 :
 5671  
                     // com\\googlecode\\sparkleg\\Sparql.g:193:12: SILENT
 5672  
                     {
 5673  0
                     SILENT121=(Token)match(input,SILENT,FOLLOW_SILENT_in_load1435);  
 5674  0
                     stream_SILENT.add(SILENT121);
 5675  
 
 5676  
 
 5677  
                     }
 5678  
                     break;
 5679  
 
 5680  
             }
 5681  
 
 5682  
 
 5683  0
             pushFollow(FOLLOW_iriRef_in_load1438);
 5684  0
             iriRef122=iriRef();
 5685  
 
 5686  0
             state._fsp--;
 5687  
 
 5688  0
             stream_iriRef.add(iriRef122.getTree());
 5689  
 
 5690  
             // com\\googlecode\\sparkleg\\Sparql.g:193:27: ( INTO graphRef )?
 5691  0
             int alt42=2;
 5692  0
             switch ( input.LA(1) ) {
 5693  
                 case INTO:
 5694  
                     {
 5695  0
                     alt42=1;
 5696  
                     }
 5697  
                     break;
 5698  
             }
 5699  
 
 5700  0
             switch (alt42) {
 5701  
                 case 1 :
 5702  
                     // com\\googlecode\\sparkleg\\Sparql.g:193:28: INTO graphRef
 5703  
                     {
 5704  0
                     INTO123=(Token)match(input,INTO,FOLLOW_INTO_in_load1441);  
 5705  0
                     stream_INTO.add(INTO123);
 5706  
 
 5707  
 
 5708  0
                     pushFollow(FOLLOW_graphRef_in_load1443);
 5709  0
                     graphRef124=graphRef();
 5710  
 
 5711  0
                     state._fsp--;
 5712  
 
 5713  0
                     stream_graphRef.add(graphRef124.getTree());
 5714  
 
 5715  
                     }
 5716  
                     break;
 5717  
 
 5718  
             }
 5719  
 
 5720  
 
 5721  
             // AST REWRITE
 5722  
             // elements: iriRef, LOAD, SILENT, graphRef
 5723  
             // token labels: 
 5724  
             // rule labels: retval
 5725  
             // token list labels: 
 5726  
             // rule list labels: 
 5727  
             // wildcard labels: 
 5728  0
             retval.tree = root_0;
 5729  0
             RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 5730  
 
 5731  0
             root_0 = (Object)adaptor.nil();
 5732  
             // 193:44: -> ^( LOAD ( SILENT )* iriRef ( graphRef )? )
 5733  
             {
 5734  
                 // com\\googlecode\\sparkleg\\Sparql.g:193:47: ^( LOAD ( SILENT )* iriRef ( graphRef )? )
 5735  
                 {
 5736  0
                 Object root_1 = (Object)adaptor.nil();
 5737  0
                 root_1 = (Object)adaptor.becomeRoot(
 5738  
                 stream_LOAD.nextNode()
 5739  
                 , root_1);
 5740  
 
 5741  
                 // com\\googlecode\\sparkleg\\Sparql.g:193:54: ( SILENT )*
 5742  0
                 while ( stream_SILENT.hasNext() ) {
 5743  0
                     adaptor.addChild(root_1, 
 5744  
                     stream_SILENT.nextNode()
 5745  
                     );
 5746  
 
 5747  
                 }
 5748  0
                 stream_SILENT.reset();
 5749  
 
 5750  0
                 adaptor.addChild(root_1, stream_iriRef.nextTree());
 5751  
 
 5752  
                 // com\\googlecode\\sparkleg\\Sparql.g:193:69: ( graphRef )?
 5753  0
                 if ( stream_graphRef.hasNext() ) {
 5754  0
                     adaptor.addChild(root_1, stream_graphRef.nextTree());
 5755  
 
 5756  
                 }
 5757  0
                 stream_graphRef.reset();
 5758  
 
 5759  0
                 adaptor.addChild(root_0, root_1);
 5760  
                 }
 5761  
 
 5762  
             }
 5763  
 
 5764  
 
 5765  0
             retval.tree = root_0;
 5766  
 
 5767  
             }
 5768  
 
 5769  0
             retval.stop = input.LT(-1);
 5770  
 
 5771  
 
 5772  0
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 5773  0
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 5774  
 
 5775  
         }
 5776  0
         catch (RecognitionException re) {
 5777  0
             reportError(re);
 5778  0
             recover(input,re);
 5779  0
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 5780  
 
 5781  
         }
 5782  
 
 5783  0
         finally {
 5784  
                 // do for sure before leaving
 5785  0
         }
 5786  0
         return retval;
 5787  
     }
 5788  
     // $ANTLR end "load"
 5789  
 
 5790  
 
 5791  8
     public static class clear_return extends ParserRuleReturnScope {
 5792  
         Object tree;
 5793  8
         public Object getTree() { return tree; }
 5794  
     };
 5795  
 
 5796  
 
 5797  
     // $ANTLR start "clear"
 5798  
     // com\\googlecode\\sparkleg\\Sparql.g:196:1: clear : CLEAR ( SILENT )? graphRefAll -> ^( CLEAR ( SILENT )* graphRefAll ) ;
 5799  
     public final SparqlParser.clear_return clear() throws RecognitionException {
 5800  8
         SparqlParser.clear_return retval = new SparqlParser.clear_return();
 5801  8
         retval.start = input.LT(1);
 5802  
 
 5803  
 
 5804  8
         Object root_0 = null;
 5805  
 
 5806  8
         Token CLEAR125=null;
 5807  8
         Token SILENT126=null;
 5808  8
         SparqlParser.graphRefAll_return graphRefAll127 =null;
 5809  
 
 5810  
 
 5811  8
         Object CLEAR125_tree=null;
 5812  8
         Object SILENT126_tree=null;
 5813  8
         RewriteRuleTokenStream stream_SILENT=new RewriteRuleTokenStream(adaptor,"token SILENT");
 5814  8
         RewriteRuleTokenStream stream_CLEAR=new RewriteRuleTokenStream(adaptor,"token CLEAR");
 5815  8
         RewriteRuleSubtreeStream stream_graphRefAll=new RewriteRuleSubtreeStream(adaptor,"rule graphRefAll");
 5816  
         try {
 5817  
             // com\\googlecode\\sparkleg\\Sparql.g:197:5: ( CLEAR ( SILENT )? graphRefAll -> ^( CLEAR ( SILENT )* graphRefAll ) )
 5818  
             // com\\googlecode\\sparkleg\\Sparql.g:197:7: CLEAR ( SILENT )? graphRefAll
 5819  
             {
 5820  8
             CLEAR125=(Token)match(input,CLEAR,FOLLOW_CLEAR_in_clear1480);  
 5821  8
             stream_CLEAR.add(CLEAR125);
 5822  
 
 5823  
 
 5824  
             // com\\googlecode\\sparkleg\\Sparql.g:197:14: ( SILENT )?
 5825  8
             int alt43=2;
 5826  8
             switch ( input.LA(1) ) {
 5827  
                 case SILENT:
 5828  
                     {
 5829  0
                     alt43=1;
 5830  
                     }
 5831  
                     break;
 5832  
             }
 5833  
 
 5834  8
             switch (alt43) {
 5835  
                 case 1 :
 5836  
                     // com\\googlecode\\sparkleg\\Sparql.g:197:14: SILENT
 5837  
                     {
 5838  0
                     SILENT126=(Token)match(input,SILENT,FOLLOW_SILENT_in_clear1483);  
 5839  0
                     stream_SILENT.add(SILENT126);
 5840  
 
 5841  
 
 5842  
                     }
 5843  
                     break;
 5844  
 
 5845  
             }
 5846  
 
 5847  
 
 5848  8
             pushFollow(FOLLOW_graphRefAll_in_clear1486);
 5849  8
             graphRefAll127=graphRefAll();
 5850  
 
 5851  8
             state._fsp--;
 5852  
 
 5853  8
             stream_graphRefAll.add(graphRefAll127.getTree());
 5854  
 
 5855  
             // AST REWRITE
 5856  
             // elements: SILENT, graphRefAll, CLEAR
 5857  
             // token labels: 
 5858  
             // rule labels: retval
 5859  
             // token list labels: 
 5860  
             // rule list labels: 
 5861  
             // wildcard labels: 
 5862  8
             retval.tree = root_0;
 5863  8
             RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 5864  
 
 5865  8
             root_0 = (Object)adaptor.nil();
 5866  
             // 197:34: -> ^( CLEAR ( SILENT )* graphRefAll )
 5867  
             {
 5868  
                 // com\\googlecode\\sparkleg\\Sparql.g:197:37: ^( CLEAR ( SILENT )* graphRefAll )
 5869  
                 {
 5870  8
                 Object root_1 = (Object)adaptor.nil();
 5871  8
                 root_1 = (Object)adaptor.becomeRoot(
 5872  
                 stream_CLEAR.nextNode()
 5873  
                 , root_1);
 5874  
 
 5875  
                 // com\\googlecode\\sparkleg\\Sparql.g:197:45: ( SILENT )*
 5876  8
                 while ( stream_SILENT.hasNext() ) {
 5877  0
                     adaptor.addChild(root_1, 
 5878  
                     stream_SILENT.nextNode()
 5879  
                     );
 5880  
 
 5881  
                 }
 5882  8
                 stream_SILENT.reset();
 5883  
 
 5884  8
                 adaptor.addChild(root_1, stream_graphRefAll.nextTree());
 5885  
 
 5886  8
                 adaptor.addChild(root_0, root_1);
 5887  
                 }
 5888  
 
 5889  
             }
 5890  
 
 5891  
 
 5892  8
             retval.tree = root_0;
 5893  
 
 5894  
             }
 5895  
 
 5896  8
             retval.stop = input.LT(-1);
 5897  
 
 5898  
 
 5899  8
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 5900  8
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 5901  
 
 5902  
         }
 5903  0
         catch (RecognitionException re) {
 5904  0
             reportError(re);
 5905  0
             recover(input,re);
 5906  0
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 5907  
 
 5908  
         }
 5909  
 
 5910  0
         finally {
 5911  
                 // do for sure before leaving
 5912  8
         }
 5913  8
         return retval;
 5914  
     }
 5915  
     // $ANTLR end "clear"
 5916  
 
 5917  
 
 5918  8
     public static class drop_return extends ParserRuleReturnScope {
 5919  
         Object tree;
 5920  8
         public Object getTree() { return tree; }
 5921  
     };
 5922  
 
 5923  
 
 5924  
     // $ANTLR start "drop"
 5925  
     // com\\googlecode\\sparkleg\\Sparql.g:200:1: drop : DROP ( SILENT )? graphRefAll -> ^( DROP ( SILENT )* graphRefAll ) ;
 5926  
     public final SparqlParser.drop_return drop() throws RecognitionException {
 5927  8
         SparqlParser.drop_return retval = new SparqlParser.drop_return();
 5928  8
         retval.start = input.LT(1);
 5929  
 
 5930  
 
 5931  8
         Object root_0 = null;
 5932  
 
 5933  8
         Token DROP128=null;
 5934  8
         Token SILENT129=null;
 5935  8
         SparqlParser.graphRefAll_return graphRefAll130 =null;
 5936  
 
 5937  
 
 5938  8
         Object DROP128_tree=null;
 5939  8
         Object SILENT129_tree=null;
 5940  8
         RewriteRuleTokenStream stream_SILENT=new RewriteRuleTokenStream(adaptor,"token SILENT");
 5941  8
         RewriteRuleTokenStream stream_DROP=new RewriteRuleTokenStream(adaptor,"token DROP");
 5942  8
         RewriteRuleSubtreeStream stream_graphRefAll=new RewriteRuleSubtreeStream(adaptor,"rule graphRefAll");
 5943  
         try {
 5944  
             // com\\googlecode\\sparkleg\\Sparql.g:201:5: ( DROP ( SILENT )? graphRefAll -> ^( DROP ( SILENT )* graphRefAll ) )
 5945  
             // com\\googlecode\\sparkleg\\Sparql.g:201:7: DROP ( SILENT )? graphRefAll
 5946  
             {
 5947  8
             DROP128=(Token)match(input,DROP,FOLLOW_DROP_in_drop1518);  
 5948  8
             stream_DROP.add(DROP128);
 5949  
 
 5950  
 
 5951  
             // com\\googlecode\\sparkleg\\Sparql.g:201:12: ( SILENT )?
 5952  8
             int alt44=2;
 5953  8
             switch ( input.LA(1) ) {
 5954  
                 case SILENT:
 5955  
                     {
 5956  0
                     alt44=1;
 5957  
                     }
 5958  
                     break;
 5959  
             }
 5960  
 
 5961  8
             switch (alt44) {
 5962  
                 case 1 :
 5963  
                     // com\\googlecode\\sparkleg\\Sparql.g:201:12: SILENT
 5964  
                     {
 5965  0
                     SILENT129=(Token)match(input,SILENT,FOLLOW_SILENT_in_drop1520);  
 5966  0
                     stream_SILENT.add(SILENT129);
 5967  
 
 5968  
 
 5969  
                     }
 5970  
                     break;
 5971  
 
 5972  
             }
 5973  
 
 5974  
 
 5975  8
             pushFollow(FOLLOW_graphRefAll_in_drop1523);
 5976  8
             graphRefAll130=graphRefAll();
 5977  
 
 5978  8
             state._fsp--;
 5979  
 
 5980  8
             stream_graphRefAll.add(graphRefAll130.getTree());
 5981  
 
 5982  
             // AST REWRITE
 5983  
             // elements: SILENT, DROP, graphRefAll
 5984  
             // token labels: 
 5985  
             // rule labels: retval
 5986  
             // token list labels: 
 5987  
             // rule list labels: 
 5988  
             // wildcard labels: 
 5989  8
             retval.tree = root_0;
 5990  8
             RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 5991  
 
 5992  8
             root_0 = (Object)adaptor.nil();
 5993  
             // 201:32: -> ^( DROP ( SILENT )* graphRefAll )
 5994  
             {
 5995  
                 // com\\googlecode\\sparkleg\\Sparql.g:201:35: ^( DROP ( SILENT )* graphRefAll )
 5996  
                 {
 5997  8
                 Object root_1 = (Object)adaptor.nil();
 5998  8
                 root_1 = (Object)adaptor.becomeRoot(
 5999  
                 stream_DROP.nextNode()
 6000  
                 , root_1);
 6001  
 
 6002  
                 // com\\googlecode\\sparkleg\\Sparql.g:201:42: ( SILENT )*
 6003  8
                 while ( stream_SILENT.hasNext() ) {
 6004  0
                     adaptor.addChild(root_1, 
 6005  
                     stream_SILENT.nextNode()
 6006  
                     );
 6007  
 
 6008  
                 }
 6009  8
                 stream_SILENT.reset();
 6010  
 
 6011  8
                 adaptor.addChild(root_1, stream_graphRefAll.nextTree());
 6012  
 
 6013  8
                 adaptor.addChild(root_0, root_1);
 6014  
                 }
 6015  
 
 6016  
             }
 6017  
 
 6018  
 
 6019  8
             retval.tree = root_0;
 6020  
 
 6021  
             }
 6022  
 
 6023  8
             retval.stop = input.LT(-1);
 6024  
 
 6025  
 
 6026  8
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 6027  8
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 6028  
 
 6029  
         }
 6030  0
         catch (RecognitionException re) {
 6031  0
             reportError(re);
 6032  0
             recover(input,re);
 6033  0
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 6034  
 
 6035  
         }
 6036  
 
 6037  0
         finally {
 6038  
                 // do for sure before leaving
 6039  8
         }
 6040  8
         return retval;
 6041  
     }
 6042  
     // $ANTLR end "drop"
 6043  
 
 6044  
 
 6045  0
     public static class create_return extends ParserRuleReturnScope {
 6046  
         Object tree;
 6047  0
         public Object getTree() { return tree; }
 6048  
     };
 6049  
 
 6050  
 
 6051  
     // $ANTLR start "create"
 6052  
     // com\\googlecode\\sparkleg\\Sparql.g:204:1: create : CREATE ( SILENT )? graphRef -> ^( CREATE ( SILENT )* graphRef ) ;
 6053  
     public final SparqlParser.create_return create() throws RecognitionException {
 6054  0
         SparqlParser.create_return retval = new SparqlParser.create_return();
 6055  0
         retval.start = input.LT(1);
 6056  
 
 6057  
 
 6058  0
         Object root_0 = null;
 6059  
 
 6060  0
         Token CREATE131=null;
 6061  0
         Token SILENT132=null;
 6062  0
         SparqlParser.graphRef_return graphRef133 =null;
 6063  
 
 6064  
 
 6065  0
         Object CREATE131_tree=null;
 6066  0
         Object SILENT132_tree=null;
 6067  0
         RewriteRuleTokenStream stream_CREATE=new RewriteRuleTokenStream(adaptor,"token CREATE");
 6068  0
         RewriteRuleTokenStream stream_SILENT=new RewriteRuleTokenStream(adaptor,"token SILENT");
 6069  0
         RewriteRuleSubtreeStream stream_graphRef=new RewriteRuleSubtreeStream(adaptor,"rule graphRef");
 6070  
         try {
 6071  
             // com\\googlecode\\sparkleg\\Sparql.g:205:5: ( CREATE ( SILENT )? graphRef -> ^( CREATE ( SILENT )* graphRef ) )
 6072  
             // com\\googlecode\\sparkleg\\Sparql.g:205:7: CREATE ( SILENT )? graphRef
 6073  
             {
 6074  0
             CREATE131=(Token)match(input,CREATE,FOLLOW_CREATE_in_create1552);  
 6075  0
             stream_CREATE.add(CREATE131);
 6076  
 
 6077  
 
 6078  
             // com\\googlecode\\sparkleg\\Sparql.g:205:14: ( SILENT )?
 6079  0
             int alt45=2;
 6080  0
             switch ( input.LA(1) ) {
 6081  
                 case SILENT:
 6082  
                     {
 6083  0
                     alt45=1;
 6084  
                     }
 6085  
                     break;
 6086  
             }
 6087  
 
 6088  0
             switch (alt45) {
 6089  
                 case 1 :
 6090  
                     // com\\googlecode\\sparkleg\\Sparql.g:205:14: SILENT
 6091  
                     {
 6092  0
                     SILENT132=(Token)match(input,SILENT,FOLLOW_SILENT_in_create1554);  
 6093  0
                     stream_SILENT.add(SILENT132);
 6094  
 
 6095  
 
 6096  
                     }
 6097  
                     break;
 6098  
 
 6099  
             }
 6100  
 
 6101  
 
 6102  0
             pushFollow(FOLLOW_graphRef_in_create1557);
 6103  0
             graphRef133=graphRef();
 6104  
 
 6105  0
             state._fsp--;
 6106  
 
 6107  0
             stream_graphRef.add(graphRef133.getTree());
 6108  
 
 6109  
             // AST REWRITE
 6110  
             // elements: SILENT, graphRef, CREATE
 6111  
             // token labels: 
 6112  
             // rule labels: retval
 6113  
             // token list labels: 
 6114  
             // rule list labels: 
 6115  
             // wildcard labels: 
 6116  0
             retval.tree = root_0;
 6117  0
             RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 6118  
 
 6119  0
             root_0 = (Object)adaptor.nil();
 6120  
             // 205:31: -> ^( CREATE ( SILENT )* graphRef )
 6121  
             {
 6122  
                 // com\\googlecode\\sparkleg\\Sparql.g:205:34: ^( CREATE ( SILENT )* graphRef )
 6123  
                 {
 6124  0
                 Object root_1 = (Object)adaptor.nil();
 6125  0
                 root_1 = (Object)adaptor.becomeRoot(
 6126  
                 stream_CREATE.nextNode()
 6127  
                 , root_1);
 6128  
 
 6129  
                 // com\\googlecode\\sparkleg\\Sparql.g:205:43: ( SILENT )*
 6130  0
                 while ( stream_SILENT.hasNext() ) {
 6131  0
                     adaptor.addChild(root_1, 
 6132  
                     stream_SILENT.nextNode()
 6133  
                     );
 6134  
 
 6135  
                 }
 6136  0
                 stream_SILENT.reset();
 6137  
 
 6138  0
                 adaptor.addChild(root_1, stream_graphRef.nextTree());
 6139  
 
 6140  0
                 adaptor.addChild(root_0, root_1);
 6141  
                 }
 6142  
 
 6143  
             }
 6144  
 
 6145  
 
 6146  0
             retval.tree = root_0;
 6147  
 
 6148  
             }
 6149  
 
 6150  0
             retval.stop = input.LT(-1);
 6151  
 
 6152  
 
 6153  0
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 6154  0
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 6155  
 
 6156  
         }
 6157  0
         catch (RecognitionException re) {
 6158  0
             reportError(re);
 6159  0
             recover(input,re);
 6160  0
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 6161  
 
 6162  
         }
 6163  
 
 6164  0
         finally {
 6165  
                 // do for sure before leaving
 6166  0
         }
 6167  0
         return retval;
 6168  
     }
 6169  
     // $ANTLR end "create"
 6170  
 
 6171  
 
 6172  0
     public static class add_return extends ParserRuleReturnScope {
 6173  
         Object tree;
 6174  0
         public Object getTree() { return tree; }
 6175  
     };
 6176  
 
 6177  
 
 6178  
     // $ANTLR start "add"
 6179  
     // com\\googlecode\\sparkleg\\Sparql.g:208:1: add : ADD ( SILENT )? from= graphOrDefault TO to= graphOrDefault -> ^( ADD ( SILENT )* $from $to) ;
 6180  
     public final SparqlParser.add_return add() throws RecognitionException {
 6181  0
         SparqlParser.add_return retval = new SparqlParser.add_return();
 6182  0
         retval.start = input.LT(1);
 6183  
 
 6184  
 
 6185  0
         Object root_0 = null;
 6186  
 
 6187  0
         Token ADD134=null;
 6188  0
         Token SILENT135=null;
 6189  0
         Token TO136=null;
 6190  0
         SparqlParser.graphOrDefault_return from =null;
 6191  
 
 6192  0
         SparqlParser.graphOrDefault_return to =null;
 6193  
 
 6194  
 
 6195  0
         Object ADD134_tree=null;
 6196  0
         Object SILENT135_tree=null;
 6197  0
         Object TO136_tree=null;
 6198  0
         RewriteRuleTokenStream stream_SILENT=new RewriteRuleTokenStream(adaptor,"token SILENT");
 6199  0
         RewriteRuleTokenStream stream_TO=new RewriteRuleTokenStream(adaptor,"token TO");
 6200  0
         RewriteRuleTokenStream stream_ADD=new RewriteRuleTokenStream(adaptor,"token ADD");
 6201  0
         RewriteRuleSubtreeStream stream_graphOrDefault=new RewriteRuleSubtreeStream(adaptor,"rule graphOrDefault");
 6202  
         try {
 6203  
             // com\\googlecode\\sparkleg\\Sparql.g:209:5: ( ADD ( SILENT )? from= graphOrDefault TO to= graphOrDefault -> ^( ADD ( SILENT )* $from $to) )
 6204  
             // com\\googlecode\\sparkleg\\Sparql.g:209:7: ADD ( SILENT )? from= graphOrDefault TO to= graphOrDefault
 6205  
             {
 6206  0
             ADD134=(Token)match(input,ADD,FOLLOW_ADD_in_add1589);  
 6207  0
             stream_ADD.add(ADD134);
 6208  
 
 6209  
 
 6210  
             // com\\googlecode\\sparkleg\\Sparql.g:209:11: ( SILENT )?
 6211  0
             int alt46=2;
 6212  0
             switch ( input.LA(1) ) {
 6213  
                 case SILENT:
 6214  
                     {
 6215  0
                     alt46=1;
 6216  
                     }
 6217  
                     break;
 6218  
             }
 6219  
 
 6220  0
             switch (alt46) {
 6221  
                 case 1 :
 6222  
                     // com\\googlecode\\sparkleg\\Sparql.g:209:11: SILENT
 6223  
                     {
 6224  0
                     SILENT135=(Token)match(input,SILENT,FOLLOW_SILENT_in_add1591);  
 6225  0
                     stream_SILENT.add(SILENT135);
 6226  
 
 6227  
 
 6228  
                     }
 6229  
                     break;
 6230  
 
 6231  
             }
 6232  
 
 6233  
 
 6234  0
             pushFollow(FOLLOW_graphOrDefault_in_add1596);
 6235  0
             from=graphOrDefault();
 6236  
 
 6237  0
             state._fsp--;
 6238  
 
 6239  0
             stream_graphOrDefault.add(from.getTree());
 6240  
 
 6241  0
             TO136=(Token)match(input,TO,FOLLOW_TO_in_add1598);  
 6242  0
             stream_TO.add(TO136);
 6243  
 
 6244  
 
 6245  0
             pushFollow(FOLLOW_graphOrDefault_in_add1602);
 6246  0
             to=graphOrDefault();
 6247  
 
 6248  0
             state._fsp--;
 6249  
 
 6250  0
             stream_graphOrDefault.add(to.getTree());
 6251  
 
 6252  
             // AST REWRITE
 6253  
             // elements: to, ADD, SILENT, from
 6254  
             // token labels: 
 6255  
             // rule labels: to, retval, from
 6256  
             // token list labels: 
 6257  
             // rule list labels: 
 6258  
             // wildcard labels: 
 6259  0
             retval.tree = root_0;
 6260  0
             RewriteRuleSubtreeStream stream_to=new RewriteRuleSubtreeStream(adaptor,"rule to",to!=null?to.tree:null);
 6261  0
             RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 6262  0
             RewriteRuleSubtreeStream stream_from=new RewriteRuleSubtreeStream(adaptor,"rule from",from!=null?from.tree:null);
 6263  
 
 6264  0
             root_0 = (Object)adaptor.nil();
 6265  
             // 209:60: -> ^( ADD ( SILENT )* $from $to)
 6266  
             {
 6267  
                 // com\\googlecode\\sparkleg\\Sparql.g:209:63: ^( ADD ( SILENT )* $from $to)
 6268  
                 {
 6269  0
                 Object root_1 = (Object)adaptor.nil();
 6270  0
                 root_1 = (Object)adaptor.becomeRoot(
 6271  
                 stream_ADD.nextNode()
 6272  
                 , root_1);
 6273  
 
 6274  
                 // com\\googlecode\\sparkleg\\Sparql.g:209:69: ( SILENT )*
 6275  0
                 while ( stream_SILENT.hasNext() ) {
 6276  0
                     adaptor.addChild(root_1, 
 6277  
                     stream_SILENT.nextNode()
 6278  
                     );
 6279  
 
 6280  
                 }
 6281  0
                 stream_SILENT.reset();
 6282  
 
 6283  0
                 adaptor.addChild(root_1, stream_from.nextTree());
 6284  
 
 6285  0
                 adaptor.addChild(root_1, stream_to.nextTree());
 6286  
 
 6287  0
                 adaptor.addChild(root_0, root_1);
 6288  
                 }
 6289  
 
 6290  
             }
 6291  
 
 6292  
 
 6293  0
             retval.tree = root_0;
 6294  
 
 6295  
             }
 6296  
 
 6297  0
             retval.stop = input.LT(-1);
 6298  
 
 6299  
 
 6300  0
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 6301  0
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 6302  
 
 6303  
         }
 6304  0
         catch (RecognitionException re) {
 6305  0
             reportError(re);
 6306  0
             recover(input,re);
 6307  0
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 6308  
 
 6309  
         }
 6310  
 
 6311  0
         finally {
 6312  
                 // do for sure before leaving
 6313  0
         }
 6314  0
         return retval;
 6315  
     }
 6316  
     // $ANTLR end "add"
 6317  
 
 6318  
 
 6319  0
     public static class move_return extends ParserRuleReturnScope {
 6320  
         Object tree;
 6321  0
         public Object getTree() { return tree; }
 6322  
     };
 6323  
 
 6324  
 
 6325  
     // $ANTLR start "move"
 6326  
     // com\\googlecode\\sparkleg\\Sparql.g:212:1: move : MOVE ( SILENT )? from= graphOrDefault TO to= graphOrDefault -> ^( MOVE ( SILENT )* $from $to) ;
 6327  
     public final SparqlParser.move_return move() throws RecognitionException {
 6328  0
         SparqlParser.move_return retval = new SparqlParser.move_return();
 6329  0
         retval.start = input.LT(1);
 6330  
 
 6331  
 
 6332  0
         Object root_0 = null;
 6333  
 
 6334  0
         Token MOVE137=null;
 6335  0
         Token SILENT138=null;
 6336  0
         Token TO139=null;
 6337  0
         SparqlParser.graphOrDefault_return from =null;
 6338  
 
 6339  0
         SparqlParser.graphOrDefault_return to =null;
 6340  
 
 6341  
 
 6342  0
         Object MOVE137_tree=null;
 6343  0
         Object SILENT138_tree=null;
 6344  0
         Object TO139_tree=null;
 6345  0
         RewriteRuleTokenStream stream_SILENT=new RewriteRuleTokenStream(adaptor,"token SILENT");
 6346  0
         RewriteRuleTokenStream stream_TO=new RewriteRuleTokenStream(adaptor,"token TO");
 6347  0
         RewriteRuleTokenStream stream_MOVE=new RewriteRuleTokenStream(adaptor,"token MOVE");
 6348  0
         RewriteRuleSubtreeStream stream_graphOrDefault=new RewriteRuleSubtreeStream(adaptor,"rule graphOrDefault");
 6349  
         try {
 6350  
             // com\\googlecode\\sparkleg\\Sparql.g:213:5: ( MOVE ( SILENT )? from= graphOrDefault TO to= graphOrDefault -> ^( MOVE ( SILENT )* $from $to) )
 6351  
             // com\\googlecode\\sparkleg\\Sparql.g:213:7: MOVE ( SILENT )? from= graphOrDefault TO to= graphOrDefault
 6352  
             {
 6353  0
             MOVE137=(Token)match(input,MOVE,FOLLOW_MOVE_in_move1638);  
 6354  0
             stream_MOVE.add(MOVE137);
 6355  
 
 6356  
 
 6357  
             // com\\googlecode\\sparkleg\\Sparql.g:213:12: ( SILENT )?
 6358  0
             int alt47=2;
 6359  0
             switch ( input.LA(1) ) {
 6360  
                 case SILENT:
 6361  
                     {
 6362  0
                     alt47=1;
 6363  
                     }
 6364  
                     break;
 6365  
             }
 6366  
 
 6367  0
             switch (alt47) {
 6368  
                 case 1 :
 6369  
                     // com\\googlecode\\sparkleg\\Sparql.g:213:12: SILENT
 6370  
                     {
 6371  0
                     SILENT138=(Token)match(input,SILENT,FOLLOW_SILENT_in_move1640);  
 6372  0
                     stream_SILENT.add(SILENT138);
 6373  
 
 6374  
 
 6375  
                     }
 6376  
                     break;
 6377  
 
 6378  
             }
 6379  
 
 6380  
 
 6381  0
             pushFollow(FOLLOW_graphOrDefault_in_move1645);
 6382  0
             from=graphOrDefault();
 6383  
 
 6384  0
             state._fsp--;
 6385  
 
 6386  0
             stream_graphOrDefault.add(from.getTree());
 6387  
 
 6388  0
             TO139=(Token)match(input,TO,FOLLOW_TO_in_move1647);  
 6389  0
             stream_TO.add(TO139);
 6390  
 
 6391  
 
 6392  0
             pushFollow(FOLLOW_graphOrDefault_in_move1651);
 6393  0
             to=graphOrDefault();
 6394  
 
 6395  0
             state._fsp--;
 6396  
 
 6397  0
             stream_graphOrDefault.add(to.getTree());
 6398  
 
 6399  
             // AST REWRITE
 6400  
             // elements: from, SILENT, MOVE, to
 6401  
             // token labels: 
 6402  
             // rule labels: to, retval, from
 6403  
             // token list labels: 
 6404  
             // rule list labels: 
 6405  
             // wildcard labels: 
 6406  0
             retval.tree = root_0;
 6407  0
             RewriteRuleSubtreeStream stream_to=new RewriteRuleSubtreeStream(adaptor,"rule to",to!=null?to.tree:null);
 6408  0
             RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 6409  0
             RewriteRuleSubtreeStream stream_from=new RewriteRuleSubtreeStream(adaptor,"rule from",from!=null?from.tree:null);
 6410  
 
 6411  0
             root_0 = (Object)adaptor.nil();
 6412  
             // 213:61: -> ^( MOVE ( SILENT )* $from $to)
 6413  
             {
 6414  
                 // com\\googlecode\\sparkleg\\Sparql.g:213:64: ^( MOVE ( SILENT )* $from $to)
 6415  
                 {
 6416  0
                 Object root_1 = (Object)adaptor.nil();
 6417  0
                 root_1 = (Object)adaptor.becomeRoot(
 6418  
                 stream_MOVE.nextNode()
 6419  
                 , root_1);
 6420  
 
 6421  
                 // com\\googlecode\\sparkleg\\Sparql.g:213:71: ( SILENT )*
 6422  0
                 while ( stream_SILENT.hasNext() ) {
 6423  0
                     adaptor.addChild(root_1, 
 6424  
                     stream_SILENT.nextNode()
 6425  
                     );
 6426  
 
 6427  
                 }
 6428  0
                 stream_SILENT.reset();
 6429  
 
 6430  0
                 adaptor.addChild(root_1, stream_from.nextTree());
 6431  
 
 6432  0
                 adaptor.addChild(root_1, stream_to.nextTree());
 6433  
 
 6434  0
                 adaptor.addChild(root_0, root_1);
 6435  
                 }
 6436  
 
 6437  
             }
 6438  
 
 6439  
 
 6440  0
             retval.tree = root_0;
 6441  
 
 6442  
             }
 6443  
 
 6444  0
             retval.stop = input.LT(-1);
 6445  
 
 6446  
 
 6447  0
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 6448  0
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 6449  
 
 6450  
         }
 6451  0
         catch (RecognitionException re) {
 6452  0
             reportError(re);
 6453  0
             recover(input,re);
 6454  0
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 6455  
 
 6456  
         }
 6457  
 
 6458  0
         finally {
 6459  
                 // do for sure before leaving
 6460  0
         }
 6461  0
         return retval;
 6462  
     }
 6463  
     // $ANTLR end "move"
 6464  
 
 6465  
 
 6466  0
     public static class copy_return extends ParserRuleReturnScope {
 6467  
         Object tree;
 6468  0
         public Object getTree() { return tree; }
 6469  
     };
 6470  
 
 6471  
 
 6472  
     // $ANTLR start "copy"
 6473  
     // com\\googlecode\\sparkleg\\Sparql.g:216:1: copy : COPY ( SILENT )? from= graphOrDefault TO to= graphOrDefault -> ^( COPY ( SILENT )* $from $to) ;
 6474  
     public final SparqlParser.copy_return copy() throws RecognitionException {
 6475  0
         SparqlParser.copy_return retval = new SparqlParser.copy_return();
 6476  0
         retval.start = input.LT(1);
 6477  
 
 6478  
 
 6479  0
         Object root_0 = null;
 6480  
 
 6481  0
         Token COPY140=null;
 6482  0
         Token SILENT141=null;
 6483  0
         Token TO142=null;
 6484  0
         SparqlParser.graphOrDefault_return from =null;
 6485  
 
 6486  0
         SparqlParser.graphOrDefault_return to =null;
 6487  
 
 6488  
 
 6489  0
         Object COPY140_tree=null;
 6490  0
         Object SILENT141_tree=null;
 6491  0
         Object TO142_tree=null;
 6492  0
         RewriteRuleTokenStream stream_SILENT=new RewriteRuleTokenStream(adaptor,"token SILENT");
 6493  0
         RewriteRuleTokenStream stream_TO=new RewriteRuleTokenStream(adaptor,"token TO");
 6494  0
         RewriteRuleTokenStream stream_COPY=new RewriteRuleTokenStream(adaptor,"token COPY");
 6495  0
         RewriteRuleSubtreeStream stream_graphOrDefault=new RewriteRuleSubtreeStream(adaptor,"rule graphOrDefault");
 6496  
         try {
 6497  
             // com\\googlecode\\sparkleg\\Sparql.g:217:5: ( COPY ( SILENT )? from= graphOrDefault TO to= graphOrDefault -> ^( COPY ( SILENT )* $from $to) )
 6498  
             // com\\googlecode\\sparkleg\\Sparql.g:217:7: COPY ( SILENT )? from= graphOrDefault TO to= graphOrDefault
 6499  
             {
 6500  0
             COPY140=(Token)match(input,COPY,FOLLOW_COPY_in_copy1687);  
 6501  0
             stream_COPY.add(COPY140);
 6502  
 
 6503  
 
 6504  
             // com\\googlecode\\sparkleg\\Sparql.g:217:12: ( SILENT )?
 6505  0
             int alt48=2;
 6506  0
             switch ( input.LA(1) ) {
 6507  
                 case SILENT:
 6508  
                     {
 6509  0
                     alt48=1;
 6510  
                     }
 6511  
                     break;
 6512  
             }
 6513  
 
 6514  0
             switch (alt48) {
 6515  
                 case 1 :
 6516  
                     // com\\googlecode\\sparkleg\\Sparql.g:217:12: SILENT
 6517  
                     {
 6518  0
                     SILENT141=(Token)match(input,SILENT,FOLLOW_SILENT_in_copy1689);  
 6519  0
                     stream_SILENT.add(SILENT141);
 6520  
 
 6521  
 
 6522  
                     }
 6523  
                     break;
 6524  
 
 6525  
             }
 6526  
 
 6527  
 
 6528  0
             pushFollow(FOLLOW_graphOrDefault_in_copy1694);
 6529  0
             from=graphOrDefault();
 6530  
 
 6531  0
             state._fsp--;
 6532  
 
 6533  0
             stream_graphOrDefault.add(from.getTree());
 6534  
 
 6535  0
             TO142=(Token)match(input,TO,FOLLOW_TO_in_copy1696);  
 6536  0
             stream_TO.add(TO142);
 6537  
 
 6538  
 
 6539  0
             pushFollow(FOLLOW_graphOrDefault_in_copy1700);
 6540  0
             to=graphOrDefault();
 6541  
 
 6542  0
             state._fsp--;
 6543  
 
 6544  0
             stream_graphOrDefault.add(to.getTree());
 6545  
 
 6546  
             // AST REWRITE
 6547  
             // elements: SILENT, to, COPY, from
 6548  
             // token labels: 
 6549  
             // rule labels: to, retval, from
 6550  
             // token list labels: 
 6551  
             // rule list labels: 
 6552  
             // wildcard labels: 
 6553  0
             retval.tree = root_0;
 6554  0
             RewriteRuleSubtreeStream stream_to=new RewriteRuleSubtreeStream(adaptor,"rule to",to!=null?to.tree:null);
 6555  0
             RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 6556  0
             RewriteRuleSubtreeStream stream_from=new RewriteRuleSubtreeStream(adaptor,"rule from",from!=null?from.tree:null);
 6557  
 
 6558  0
             root_0 = (Object)adaptor.nil();
 6559  
             // 217:61: -> ^( COPY ( SILENT )* $from $to)
 6560  
             {
 6561  
                 // com\\googlecode\\sparkleg\\Sparql.g:217:64: ^( COPY ( SILENT )* $from $to)
 6562  
                 {
 6563  0
                 Object root_1 = (Object)adaptor.nil();
 6564  0
                 root_1 = (Object)adaptor.becomeRoot(
 6565  
                 stream_COPY.nextNode()
 6566  
                 , root_1);
 6567  
 
 6568  
                 // com\\googlecode\\sparkleg\\Sparql.g:217:71: ( SILENT )*
 6569  0
                 while ( stream_SILENT.hasNext() ) {
 6570  0
                     adaptor.addChild(root_1, 
 6571  
                     stream_SILENT.nextNode()
 6572  
                     );
 6573  
 
 6574  
                 }
 6575  0
                 stream_SILENT.reset();
 6576  
 
 6577  0
                 adaptor.addChild(root_1, stream_from.nextTree());
 6578  
 
 6579  0
                 adaptor.addChild(root_1, stream_to.nextTree());
 6580  
 
 6581  0
                 adaptor.addChild(root_0, root_1);
 6582  
                 }
 6583  
 
 6584  
             }
 6585  
 
 6586  
 
 6587  0
             retval.tree = root_0;
 6588  
 
 6589  
             }
 6590  
 
 6591  0
             retval.stop = input.LT(-1);
 6592  
 
 6593  
 
 6594  0
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 6595  0
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 6596  
 
 6597  
         }
 6598  0
         catch (RecognitionException re) {
 6599  0
             reportError(re);
 6600  0
             recover(input,re);
 6601  0
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 6602  
 
 6603  
         }
 6604  
 
 6605  0
         finally {
 6606  
                 // do for sure before leaving
 6607  0
         }
 6608  0
         return retval;
 6609  
     }
 6610  
     // $ANTLR end "copy"
 6611  
 
 6612  
 
 6613  8
     public static class insert_return extends ParserRuleReturnScope {
 6614  
         Object tree;
 6615  8
         public Object getTree() { return tree; }
 6616  
     };
 6617  
 
 6618  
 
 6619  
     // $ANTLR start "insert"
 6620  
     // com\\googlecode\\sparkleg\\Sparql.g:220:1: insert : INSERT DATA quadPattern -> ^( INSERT DATA quadPattern ) ;
 6621  
     public final SparqlParser.insert_return insert() throws RecognitionException {
 6622  8
         SparqlParser.insert_return retval = new SparqlParser.insert_return();
 6623  8
         retval.start = input.LT(1);
 6624  
 
 6625  
 
 6626  8
         Object root_0 = null;
 6627  
 
 6628  8
         Token INSERT143=null;
 6629  8
         Token DATA144=null;
 6630  8
         SparqlParser.quadPattern_return quadPattern145 =null;
 6631  
 
 6632  
 
 6633  8
         Object INSERT143_tree=null;
 6634  8
         Object DATA144_tree=null;
 6635  8
         RewriteRuleTokenStream stream_INSERT=new RewriteRuleTokenStream(adaptor,"token INSERT");
 6636  8
         RewriteRuleTokenStream stream_DATA=new RewriteRuleTokenStream(adaptor,"token DATA");
 6637  8
         RewriteRuleSubtreeStream stream_quadPattern=new RewriteRuleSubtreeStream(adaptor,"rule quadPattern");
 6638  
         try {
 6639  
             // com\\googlecode\\sparkleg\\Sparql.g:221:5: ( INSERT DATA quadPattern -> ^( INSERT DATA quadPattern ) )
 6640  
             // com\\googlecode\\sparkleg\\Sparql.g:221:7: INSERT DATA quadPattern
 6641  
             {
 6642  8
             INSERT143=(Token)match(input,INSERT,FOLLOW_INSERT_in_insert1732);  
 6643  8
             stream_INSERT.add(INSERT143);
 6644  
 
 6645  
 
 6646  8
             DATA144=(Token)match(input,DATA,FOLLOW_DATA_in_insert1734);  
 6647  8
             stream_DATA.add(DATA144);
 6648  
 
 6649  
 
 6650  8
             pushFollow(FOLLOW_quadPattern_in_insert1736);
 6651  8
             quadPattern145=quadPattern();
 6652  
 
 6653  8
             state._fsp--;
 6654  
 
 6655  8
             stream_quadPattern.add(quadPattern145.getTree());
 6656  
 
 6657  
             // AST REWRITE
 6658  
             // elements: quadPattern, INSERT, DATA
 6659  
             // token labels: 
 6660  
             // rule labels: retval
 6661  
             // token list labels: 
 6662  
             // rule list labels: 
 6663  
             // wildcard labels: 
 6664  8
             retval.tree = root_0;
 6665  8
             RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 6666  
 
 6667  8
             root_0 = (Object)adaptor.nil();
 6668  
             // 221:31: -> ^( INSERT DATA quadPattern )
 6669  
             {
 6670  
                 // com\\googlecode\\sparkleg\\Sparql.g:221:34: ^( INSERT DATA quadPattern )
 6671  
                 {
 6672  8
                 Object root_1 = (Object)adaptor.nil();
 6673  8
                 root_1 = (Object)adaptor.becomeRoot(
 6674  
                 stream_INSERT.nextNode()
 6675  
                 , root_1);
 6676  
 
 6677  8
                 adaptor.addChild(root_1, 
 6678  
                 stream_DATA.nextNode()
 6679  
                 );
 6680  
 
 6681  8
                 adaptor.addChild(root_1, stream_quadPattern.nextTree());
 6682  
 
 6683  8
                 adaptor.addChild(root_0, root_1);
 6684  
                 }
 6685  
 
 6686  
             }
 6687  
 
 6688  
 
 6689  8
             retval.tree = root_0;
 6690  
 
 6691  
             }
 6692  
 
 6693  8
             retval.stop = input.LT(-1);
 6694  
 
 6695  
 
 6696  8
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 6697  8
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 6698  
 
 6699  
         }
 6700  0
         catch (RecognitionException re) {
 6701  0
             reportError(re);
 6702  0
             recover(input,re);
 6703  0
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 6704  
 
 6705  
         }
 6706  
 
 6707  0
         finally {
 6708  
                 // do for sure before leaving
 6709  8
         }
 6710  8
         return retval;
 6711  
     }
 6712  
     // $ANTLR end "insert"
 6713  
 
 6714  
 
 6715  24
     public static class delete_return extends ParserRuleReturnScope {
 6716  
         Object tree;
 6717  24
         public Object getTree() { return tree; }
 6718  
     };
 6719  
 
 6720  
 
 6721  
     // $ANTLR start "delete"
 6722  
     // com\\googlecode\\sparkleg\\Sparql.g:224:1: delete : ( DELETE deleteData -> ^( DELETE deleteData ) | DELETE deleteWhere -> ^( DELETE deleteWhere ) );
 6723  
     public final SparqlParser.delete_return delete() throws RecognitionException {
 6724  24
         SparqlParser.delete_return retval = new SparqlParser.delete_return();
 6725  24
         retval.start = input.LT(1);
 6726  
 
 6727  
 
 6728  24
         Object root_0 = null;
 6729  
 
 6730  24
         Token DELETE146=null;
 6731  24
         Token DELETE148=null;
 6732  24
         SparqlParser.deleteData_return deleteData147 =null;
 6733  
 
 6734  24
         SparqlParser.deleteWhere_return deleteWhere149 =null;
 6735  
 
 6736  
 
 6737  24
         Object DELETE146_tree=null;
 6738  24
         Object DELETE148_tree=null;
 6739  24
         RewriteRuleTokenStream stream_DELETE=new RewriteRuleTokenStream(adaptor,"token DELETE");
 6740  24
         RewriteRuleSubtreeStream stream_deleteData=new RewriteRuleSubtreeStream(adaptor,"rule deleteData");
 6741  24
         RewriteRuleSubtreeStream stream_deleteWhere=new RewriteRuleSubtreeStream(adaptor,"rule deleteWhere");
 6742  
         try {
 6743  
             // com\\googlecode\\sparkleg\\Sparql.g:225:5: ( DELETE deleteData -> ^( DELETE deleteData ) | DELETE deleteWhere -> ^( DELETE deleteWhere ) )
 6744  24
             int alt49=2;
 6745  24
             switch ( input.LA(1) ) {
 6746  
             case DELETE:
 6747  
                 {
 6748  24
                 switch ( input.LA(2) ) {
 6749  
                 case DATA:
 6750  
                     {
 6751  12
                     alt49=1;
 6752  
                     }
 6753  12
                     break;
 6754  
                 case WHERE:
 6755  
                     {
 6756  12
                     alt49=2;
 6757  
                     }
 6758  12
                     break;
 6759  
                 default:
 6760  0
                     NoViableAltException nvae =
 6761  
                         new NoViableAltException("", 49, 1, input);
 6762  
 
 6763  0
                     throw nvae;
 6764  
 
 6765  
                 }
 6766  
 
 6767  
                 }
 6768  24
                 break;
 6769  
             default:
 6770  0
                 NoViableAltException nvae =
 6771  
                     new NoViableAltException("", 49, 0, input);
 6772  
 
 6773  0
                 throw nvae;
 6774  
 
 6775  
             }
 6776  
 
 6777  24
             switch (alt49) {
 6778  
                 case 1 :
 6779  
                     // com\\googlecode\\sparkleg\\Sparql.g:225:7: DELETE deleteData
 6780  
                     {
 6781  12
                     DELETE146=(Token)match(input,DELETE,FOLLOW_DELETE_in_delete1770);  
 6782  12
                     stream_DELETE.add(DELETE146);
 6783  
 
 6784  
 
 6785  12
                     pushFollow(FOLLOW_deleteData_in_delete1772);
 6786  12
                     deleteData147=deleteData();
 6787  
 
 6788  12
                     state._fsp--;
 6789  
 
 6790  12
                     stream_deleteData.add(deleteData147.getTree());
 6791  
 
 6792  
                     // AST REWRITE
 6793  
                     // elements: DELETE, deleteData
 6794  
                     // token labels: 
 6795  
                     // rule labels: retval
 6796  
                     // token list labels: 
 6797  
                     // rule list labels: 
 6798  
                     // wildcard labels: 
 6799  12
                     retval.tree = root_0;
 6800  12
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 6801  
 
 6802  12
                     root_0 = (Object)adaptor.nil();
 6803  
                     // 225:25: -> ^( DELETE deleteData )
 6804  
                     {
 6805  
                         // com\\googlecode\\sparkleg\\Sparql.g:225:28: ^( DELETE deleteData )
 6806  
                         {
 6807  12
                         Object root_1 = (Object)adaptor.nil();
 6808  12
                         root_1 = (Object)adaptor.becomeRoot(
 6809  
                         stream_DELETE.nextNode()
 6810  
                         , root_1);
 6811  
 
 6812  12
                         adaptor.addChild(root_1, stream_deleteData.nextTree());
 6813  
 
 6814  12
                         adaptor.addChild(root_0, root_1);
 6815  
                         }
 6816  
 
 6817  
                     }
 6818  
 
 6819  
 
 6820  12
                     retval.tree = root_0;
 6821  
 
 6822  
                     }
 6823  12
                     break;
 6824  
                 case 2 :
 6825  
                     // com\\googlecode\\sparkleg\\Sparql.g:226:7: DELETE deleteWhere
 6826  
                     {
 6827  12
                     DELETE148=(Token)match(input,DELETE,FOLLOW_DELETE_in_delete1788);  
 6828  12
                     stream_DELETE.add(DELETE148);
 6829  
 
 6830  
 
 6831  12
                     pushFollow(FOLLOW_deleteWhere_in_delete1790);
 6832  12
                     deleteWhere149=deleteWhere();
 6833  
 
 6834  12
                     state._fsp--;
 6835  
 
 6836  12
                     stream_deleteWhere.add(deleteWhere149.getTree());
 6837  
 
 6838  
                     // AST REWRITE
 6839  
                     // elements: deleteWhere, DELETE
 6840  
                     // token labels: 
 6841  
                     // rule labels: retval
 6842  
                     // token list labels: 
 6843  
                     // rule list labels: 
 6844  
                     // wildcard labels: 
 6845  12
                     retval.tree = root_0;
 6846  12
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 6847  
 
 6848  12
                     root_0 = (Object)adaptor.nil();
 6849  
                     // 226:26: -> ^( DELETE deleteWhere )
 6850  
                     {
 6851  
                         // com\\googlecode\\sparkleg\\Sparql.g:226:29: ^( DELETE deleteWhere )
 6852  
                         {
 6853  12
                         Object root_1 = (Object)adaptor.nil();
 6854  12
                         root_1 = (Object)adaptor.becomeRoot(
 6855  
                         stream_DELETE.nextNode()
 6856  
                         , root_1);
 6857  
 
 6858  12
                         adaptor.addChild(root_1, stream_deleteWhere.nextTree());
 6859  
 
 6860  12
                         adaptor.addChild(root_0, root_1);
 6861  
                         }
 6862  
 
 6863  
                     }
 6864  
 
 6865  
 
 6866  12
                     retval.tree = root_0;
 6867  
 
 6868  
                     }
 6869  
                     break;
 6870  
 
 6871  
             }
 6872  24
             retval.stop = input.LT(-1);
 6873  
 
 6874  
 
 6875  24
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 6876  24
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 6877  
 
 6878  
         }
 6879  0
         catch (RecognitionException re) {
 6880  0
             reportError(re);
 6881  0
             recover(input,re);
 6882  0
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 6883  
 
 6884  
         }
 6885  
 
 6886  0
         finally {
 6887  
                 // do for sure before leaving
 6888  24
         }
 6889  24
         return retval;
 6890  
     }
 6891  
     // $ANTLR end "delete"
 6892  
 
 6893  
 
 6894  12
     public static class deleteData_return extends ParserRuleReturnScope {
 6895  
         Object tree;
 6896  12
         public Object getTree() { return tree; }
 6897  
     };
 6898  
 
 6899  
 
 6900  
     // $ANTLR start "deleteData"
 6901  
     // com\\googlecode\\sparkleg\\Sparql.g:229:1: deleteData : DATA quadPattern -> ^( DELETE DATA quadPattern ) ;
 6902  
     public final SparqlParser.deleteData_return deleteData() throws RecognitionException {
 6903  12
         SparqlParser.deleteData_return retval = new SparqlParser.deleteData_return();
 6904  12
         retval.start = input.LT(1);
 6905  
 
 6906  
 
 6907  12
         Object root_0 = null;
 6908  
 
 6909  12
         Token DATA150=null;
 6910  12
         SparqlParser.quadPattern_return quadPattern151 =null;
 6911  
 
 6912  
 
 6913  12
         Object DATA150_tree=null;
 6914  12
         RewriteRuleTokenStream stream_DATA=new RewriteRuleTokenStream(adaptor,"token DATA");
 6915  12
         RewriteRuleSubtreeStream stream_quadPattern=new RewriteRuleSubtreeStream(adaptor,"rule quadPattern");
 6916  
         try {
 6917  
             // com\\googlecode\\sparkleg\\Sparql.g:230:5: ( DATA quadPattern -> ^( DELETE DATA quadPattern ) )
 6918  
             // com\\googlecode\\sparkleg\\Sparql.g:230:7: DATA quadPattern
 6919  
             {
 6920  12
             DATA150=(Token)match(input,DATA,FOLLOW_DATA_in_deleteData1815);  
 6921  12
             stream_DATA.add(DATA150);
 6922  
 
 6923  
 
 6924  12
             pushFollow(FOLLOW_quadPattern_in_deleteData1817);
 6925  12
             quadPattern151=quadPattern();
 6926  
 
 6927  12
             state._fsp--;
 6928  
 
 6929  12
             stream_quadPattern.add(quadPattern151.getTree());
 6930  
 
 6931  
             // AST REWRITE
 6932  
             // elements: DATA, quadPattern
 6933  
             // token labels: 
 6934  
             // rule labels: retval
 6935  
             // token list labels: 
 6936  
             // rule list labels: 
 6937  
             // wildcard labels: 
 6938  12
             retval.tree = root_0;
 6939  12
             RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 6940  
 
 6941  12
             root_0 = (Object)adaptor.nil();
 6942  
             // 230:24: -> ^( DELETE DATA quadPattern )
 6943  
             {
 6944  
                 // com\\googlecode\\sparkleg\\Sparql.g:230:27: ^( DELETE DATA quadPattern )
 6945  
                 {
 6946  12
                 Object root_1 = (Object)adaptor.nil();
 6947  12
                 root_1 = (Object)adaptor.becomeRoot(
 6948  
                 (Object)adaptor.create(DELETE, "DELETE")
 6949  
                 , root_1);
 6950  
 
 6951  12
                 adaptor.addChild(root_1, 
 6952  
                 stream_DATA.nextNode()
 6953  
                 );
 6954  
 
 6955  12
                 adaptor.addChild(root_1, stream_quadPattern.nextTree());
 6956  
 
 6957  12
                 adaptor.addChild(root_0, root_1);
 6958  
                 }
 6959  
 
 6960  
             }
 6961  
 
 6962  
 
 6963  12
             retval.tree = root_0;
 6964  
 
 6965  
             }
 6966  
 
 6967  12
             retval.stop = input.LT(-1);
 6968  
 
 6969  
 
 6970  12
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 6971  12
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 6972  
 
 6973  
         }
 6974  0
         catch (RecognitionException re) {
 6975  0
             reportError(re);
 6976  0
             recover(input,re);
 6977  0
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 6978  
 
 6979  
         }
 6980  
 
 6981  0
         finally {
 6982  
                 // do for sure before leaving
 6983  12
         }
 6984  12
         return retval;
 6985  
     }
 6986  
     // $ANTLR end "deleteData"
 6987  
 
 6988  
 
 6989  12
     public static class deleteWhere_return extends ParserRuleReturnScope {
 6990  
         Object tree;
 6991  12
         public Object getTree() { return tree; }
 6992  
     };
 6993  
 
 6994  
 
 6995  
     // $ANTLR start "deleteWhere"
 6996  
     // com\\googlecode\\sparkleg\\Sparql.g:233:1: deleteWhere : WHERE quadPattern -> ^( DELETE WHERE quadPattern ) ;
 6997  
     public final SparqlParser.deleteWhere_return deleteWhere() throws RecognitionException {
 6998  12
         SparqlParser.deleteWhere_return retval = new SparqlParser.deleteWhere_return();
 6999  12
         retval.start = input.LT(1);
 7000  
 
 7001  
 
 7002  12
         Object root_0 = null;
 7003  
 
 7004  12
         Token WHERE152=null;
 7005  12
         SparqlParser.quadPattern_return quadPattern153 =null;
 7006  
 
 7007  
 
 7008  12
         Object WHERE152_tree=null;
 7009  12
         RewriteRuleTokenStream stream_WHERE=new RewriteRuleTokenStream(adaptor,"token WHERE");
 7010  12
         RewriteRuleSubtreeStream stream_quadPattern=new RewriteRuleSubtreeStream(adaptor,"rule quadPattern");
 7011  
         try {
 7012  
             // com\\googlecode\\sparkleg\\Sparql.g:234:5: ( WHERE quadPattern -> ^( DELETE WHERE quadPattern ) )
 7013  
             // com\\googlecode\\sparkleg\\Sparql.g:234:7: WHERE quadPattern
 7014  
             {
 7015  12
             WHERE152=(Token)match(input,WHERE,FOLLOW_WHERE_in_deleteWhere1844);  
 7016  12
             stream_WHERE.add(WHERE152);
 7017  
 
 7018  
 
 7019  12
             pushFollow(FOLLOW_quadPattern_in_deleteWhere1846);
 7020  12
             quadPattern153=quadPattern();
 7021  
 
 7022  12
             state._fsp--;
 7023  
 
 7024  12
             stream_quadPattern.add(quadPattern153.getTree());
 7025  
 
 7026  
             // AST REWRITE
 7027  
             // elements: quadPattern, WHERE
 7028  
             // token labels: 
 7029  
             // rule labels: retval
 7030  
             // token list labels: 
 7031  
             // rule list labels: 
 7032  
             // wildcard labels: 
 7033  12
             retval.tree = root_0;
 7034  12
             RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 7035  
 
 7036  12
             root_0 = (Object)adaptor.nil();
 7037  
             // 234:25: -> ^( DELETE WHERE quadPattern )
 7038  
             {
 7039  
                 // com\\googlecode\\sparkleg\\Sparql.g:234:28: ^( DELETE WHERE quadPattern )
 7040  
                 {
 7041  12
                 Object root_1 = (Object)adaptor.nil();
 7042  12
                 root_1 = (Object)adaptor.becomeRoot(
 7043  
                 (Object)adaptor.create(DELETE, "DELETE")
 7044  
                 , root_1);
 7045  
 
 7046  12
                 adaptor.addChild(root_1, 
 7047  
                 stream_WHERE.nextNode()
 7048  
                 );
 7049  
 
 7050  12
                 adaptor.addChild(root_1, stream_quadPattern.nextTree());
 7051  
 
 7052  12
                 adaptor.addChild(root_0, root_1);
 7053  
                 }
 7054  
 
 7055  
             }
 7056  
 
 7057  
 
 7058  12
             retval.tree = root_0;
 7059  
 
 7060  
             }
 7061  
 
 7062  12
             retval.stop = input.LT(-1);
 7063  
 
 7064  
 
 7065  12
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 7066  12
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 7067  
 
 7068  
         }
 7069  0
         catch (RecognitionException re) {
 7070  0
             reportError(re);
 7071  0
             recover(input,re);
 7072  0
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 7073  
 
 7074  
         }
 7075  
 
 7076  0
         finally {
 7077  
                 // do for sure before leaving
 7078  12
         }
 7079  12
         return retval;
 7080  
     }
 7081  
     // $ANTLR end "deleteWhere"
 7082  
 
 7083  
 
 7084  80
     public static class modify_return extends ParserRuleReturnScope {
 7085  
         Object tree;
 7086  80
         public Object getTree() { return tree; }
 7087  
     };
 7088  
 
 7089  
 
 7090  
     // $ANTLR start "modify"
 7091  
     // com\\googlecode\\sparkleg\\Sparql.g:237:1: modify : ( WITH iriRef )? ( deleteClause ( insertClause )? | insertClause ) ( usingClause )* WHERE groupGraphPattern -> ^( MODIFY ( WITH iriRef )? ( deleteClause )* ( insertClause )* ( usingClause )* ^( WHERE_CLAUSE groupGraphPattern ) ) ;
 7092  
     public final SparqlParser.modify_return modify() throws RecognitionException {
 7093  80
         SparqlParser.modify_return retval = new SparqlParser.modify_return();
 7094  80
         retval.start = input.LT(1);
 7095  
 
 7096  
 
 7097  80
         Object root_0 = null;
 7098  
 
 7099  80
         Token WITH154=null;
 7100  80
         Token WHERE160=null;
 7101  80
         SparqlParser.iriRef_return iriRef155 =null;
 7102  
 
 7103  80
         SparqlParser.deleteClause_return deleteClause156 =null;
 7104  
 
 7105  80
         SparqlParser.insertClause_return insertClause157 =null;
 7106  
 
 7107  80
         SparqlParser.insertClause_return insertClause158 =null;
 7108  
 
 7109  80
         SparqlParser.usingClause_return usingClause159 =null;
 7110  
 
 7111  80
         SparqlParser.groupGraphPattern_return groupGraphPattern161 =null;
 7112  
 
 7113  
 
 7114  80
         Object WITH154_tree=null;
 7115  80
         Object WHERE160_tree=null;
 7116  80
         RewriteRuleTokenStream stream_WHERE=new RewriteRuleTokenStream(adaptor,"token WHERE");
 7117  80
         RewriteRuleTokenStream stream_WITH=new RewriteRuleTokenStream(adaptor,"token WITH");
 7118  80
         RewriteRuleSubtreeStream stream_deleteClause=new RewriteRuleSubtreeStream(adaptor,"rule deleteClause");
 7119  80
         RewriteRuleSubtreeStream stream_groupGraphPattern=new RewriteRuleSubtreeStream(adaptor,"rule groupGraphPattern");
 7120  80
         RewriteRuleSubtreeStream stream_iriRef=new RewriteRuleSubtreeStream(adaptor,"rule iriRef");
 7121  80
         RewriteRuleSubtreeStream stream_insertClause=new RewriteRuleSubtreeStream(adaptor,"rule insertClause");
 7122  80
         RewriteRuleSubtreeStream stream_usingClause=new RewriteRuleSubtreeStream(adaptor,"rule usingClause");
 7123  
         try {
 7124  
             // com\\googlecode\\sparkleg\\Sparql.g:238:5: ( ( WITH iriRef )? ( deleteClause ( insertClause )? | insertClause ) ( usingClause )* WHERE groupGraphPattern -> ^( MODIFY ( WITH iriRef )? ( deleteClause )* ( insertClause )* ( usingClause )* ^( WHERE_CLAUSE groupGraphPattern ) ) )
 7125  
             // com\\googlecode\\sparkleg\\Sparql.g:238:7: ( WITH iriRef )? ( deleteClause ( insertClause )? | insertClause ) ( usingClause )* WHERE groupGraphPattern
 7126  
             {
 7127  
             // com\\googlecode\\sparkleg\\Sparql.g:238:7: ( WITH iriRef )?
 7128  80
             int alt50=2;
 7129  80
             switch ( input.LA(1) ) {
 7130  
                 case WITH:
 7131  
                     {
 7132  14
                     alt50=1;
 7133  
                     }
 7134  
                     break;
 7135  
             }
 7136  
 
 7137  80
             switch (alt50) {
 7138  
                 case 1 :
 7139  
                     // com\\googlecode\\sparkleg\\Sparql.g:238:8: WITH iriRef
 7140  
                     {
 7141  14
                     WITH154=(Token)match(input,WITH,FOLLOW_WITH_in_modify1878);  
 7142  14
                     stream_WITH.add(WITH154);
 7143  
 
 7144  
 
 7145  14
                     pushFollow(FOLLOW_iriRef_in_modify1880);
 7146  14
                     iriRef155=iriRef();
 7147  
 
 7148  14
                     state._fsp--;
 7149  
 
 7150  14
                     stream_iriRef.add(iriRef155.getTree());
 7151  
 
 7152  
                     }
 7153  
                     break;
 7154  
 
 7155  
             }
 7156  
 
 7157  
 
 7158  
             // com\\googlecode\\sparkleg\\Sparql.g:238:22: ( deleteClause ( insertClause )? | insertClause )
 7159  80
             int alt52=2;
 7160  80
             switch ( input.LA(1) ) {
 7161  
             case DELETE:
 7162  
                 {
 7163  66
                 alt52=1;
 7164  
                 }
 7165  66
                 break;
 7166  
             case INSERT:
 7167  
                 {
 7168  14
                 alt52=2;
 7169  
                 }
 7170  14
                 break;
 7171  
             default:
 7172  0
                 NoViableAltException nvae =
 7173  
                     new NoViableAltException("", 52, 0, input);
 7174  
 
 7175  0
                 throw nvae;
 7176  
 
 7177  
             }
 7178  
 
 7179  80
             switch (alt52) {
 7180  
                 case 1 :
 7181  
                     // com\\googlecode\\sparkleg\\Sparql.g:238:23: deleteClause ( insertClause )?
 7182  
                     {
 7183  66
                     pushFollow(FOLLOW_deleteClause_in_modify1885);
 7184  66
                     deleteClause156=deleteClause();
 7185  
 
 7186  66
                     state._fsp--;
 7187  
 
 7188  66
                     stream_deleteClause.add(deleteClause156.getTree());
 7189  
 
 7190  
                     // com\\googlecode\\sparkleg\\Sparql.g:238:36: ( insertClause )?
 7191  66
                     int alt51=2;
 7192  66
                     switch ( input.LA(1) ) {
 7193  
                         case INSERT:
 7194  
                             {
 7195  10
                             alt51=1;
 7196  
                             }
 7197  
                             break;
 7198  
                     }
 7199  
 
 7200  66
                     switch (alt51) {
 7201  
                         case 1 :
 7202  
                             // com\\googlecode\\sparkleg\\Sparql.g:238:36: insertClause
 7203  
                             {
 7204  10
                             pushFollow(FOLLOW_insertClause_in_modify1887);
 7205  10
                             insertClause157=insertClause();
 7206  
 
 7207  10
                             state._fsp--;
 7208  
 
 7209  10
                             stream_insertClause.add(insertClause157.getTree());
 7210  
 
 7211  
                             }
 7212  
                             break;
 7213  
 
 7214  
                     }
 7215  
 
 7216  
 
 7217  
                     }
 7218  66
                     break;
 7219  
                 case 2 :
 7220  
                     // com\\googlecode\\sparkleg\\Sparql.g:238:52: insertClause
 7221  
                     {
 7222  14
                     pushFollow(FOLLOW_insertClause_in_modify1892);
 7223  14
                     insertClause158=insertClause();
 7224  
 
 7225  14
                     state._fsp--;
 7226  
 
 7227  14
                     stream_insertClause.add(insertClause158.getTree());
 7228  
 
 7229  
                     }
 7230  
                     break;
 7231  
 
 7232  
             }
 7233  
 
 7234  
 
 7235  
             // com\\googlecode\\sparkleg\\Sparql.g:238:66: ( usingClause )*
 7236  
             loop53:
 7237  
             do {
 7238  95
                 int alt53=2;
 7239  95
                 switch ( input.LA(1) ) {
 7240  
                 case USING:
 7241  
                     {
 7242  15
                     alt53=1;
 7243  
                     }
 7244  
                     break;
 7245  
 
 7246  
                 }
 7247  
 
 7248  95
                 switch (alt53) {
 7249  
                     case 1 :
 7250  
                         // com\\googlecode\\sparkleg\\Sparql.g:238:66: usingClause
 7251  
                         {
 7252  15
                         pushFollow(FOLLOW_usingClause_in_modify1895);
 7253  15
                         usingClause159=usingClause();
 7254  
 
 7255  15
                         state._fsp--;
 7256  
 
 7257  15
                         stream_usingClause.add(usingClause159.getTree());
 7258  
 
 7259  
                         }
 7260  15
                         break;
 7261  
 
 7262  
                     default :
 7263  80
                         break loop53;
 7264  
                 }
 7265  15
             } while (true);
 7266  
 
 7267  
 
 7268  80
             WHERE160=(Token)match(input,WHERE,FOLLOW_WHERE_in_modify1898);  
 7269  80
             stream_WHERE.add(WHERE160);
 7270  
 
 7271  
 
 7272  80
             pushFollow(FOLLOW_groupGraphPattern_in_modify1900);
 7273  80
             groupGraphPattern161=groupGraphPattern();
 7274  
 
 7275  80
             state._fsp--;
 7276  
 
 7277  80
             stream_groupGraphPattern.add(groupGraphPattern161.getTree());
 7278  
 
 7279  
             // AST REWRITE
 7280  
             // elements: deleteClause, insertClause, usingClause, iriRef, WITH, groupGraphPattern
 7281  
             // token labels: 
 7282  
             // rule labels: retval
 7283  
             // token list labels: 
 7284  
             // rule list labels: 
 7285  
             // wildcard labels: 
 7286  80
             retval.tree = root_0;
 7287  80
             RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 7288  
 
 7289  80
             root_0 = (Object)adaptor.nil();
 7290  
             // 238:103: -> ^( MODIFY ( WITH iriRef )? ( deleteClause )* ( insertClause )* ( usingClause )* ^( WHERE_CLAUSE groupGraphPattern ) )
 7291  
             {
 7292  
                 // com\\googlecode\\sparkleg\\Sparql.g:238:106: ^( MODIFY ( WITH iriRef )? ( deleteClause )* ( insertClause )* ( usingClause )* ^( WHERE_CLAUSE groupGraphPattern ) )
 7293  
                 {
 7294  80
                 Object root_1 = (Object)adaptor.nil();
 7295  80
                 root_1 = (Object)adaptor.becomeRoot(
 7296  
                 (Object)adaptor.create(MODIFY, "MODIFY")
 7297  
                 , root_1);
 7298  
 
 7299  
                 // com\\googlecode\\sparkleg\\Sparql.g:238:115: ( WITH iriRef )?
 7300  80
                 if ( stream_iriRef.hasNext()||stream_WITH.hasNext() ) {
 7301  14
                     adaptor.addChild(root_1, 
 7302  
                     stream_WITH.nextNode()
 7303  
                     );
 7304  
 
 7305  14
                     adaptor.addChild(root_1, stream_iriRef.nextTree());
 7306  
 
 7307  
                 }
 7308  80
                 stream_iriRef.reset();
 7309  80
                 stream_WITH.reset();
 7310  
 
 7311  
                 // com\\googlecode\\sparkleg\\Sparql.g:238:130: ( deleteClause )*
 7312  146
                 while ( stream_deleteClause.hasNext() ) {
 7313  66
                     adaptor.addChild(root_1, stream_deleteClause.nextTree());
 7314  
 
 7315  
                 }
 7316  80
                 stream_deleteClause.reset();
 7317  
 
 7318  
                 // com\\googlecode\\sparkleg\\Sparql.g:238:144: ( insertClause )*
 7319  104
                 while ( stream_insertClause.hasNext() ) {
 7320  24
                     adaptor.addChild(root_1, stream_insertClause.nextTree());
 7321  
 
 7322  
                 }
 7323  80
                 stream_insertClause.reset();
 7324  
 
 7325  
                 // com\\googlecode\\sparkleg\\Sparql.g:238:158: ( usingClause )*
 7326  95
                 while ( stream_usingClause.hasNext() ) {
 7327  15
                     adaptor.addChild(root_1, stream_usingClause.nextTree());
 7328  
 
 7329  
                 }
 7330  80
                 stream_usingClause.reset();
 7331  
 
 7332  
                 // com\\googlecode\\sparkleg\\Sparql.g:238:171: ^( WHERE_CLAUSE groupGraphPattern )
 7333  
                 {
 7334  80
                 Object root_2 = (Object)adaptor.nil();
 7335  80
                 root_2 = (Object)adaptor.becomeRoot(
 7336  
                 (Object)adaptor.create(WHERE_CLAUSE, "WHERE_CLAUSE")
 7337  
                 , root_2);
 7338  
 
 7339  80
                 adaptor.addChild(root_2, stream_groupGraphPattern.nextTree());
 7340  
 
 7341  80
                 adaptor.addChild(root_1, root_2);
 7342  
                 }
 7343  
 
 7344  80
                 adaptor.addChild(root_0, root_1);
 7345  
                 }
 7346  
 
 7347  
             }
 7348  
 
 7349  
 
 7350  80
             retval.tree = root_0;
 7351  
 
 7352  
             }
 7353  
 
 7354  80
             retval.stop = input.LT(-1);
 7355  
 
 7356  
 
 7357  80
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 7358  80
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 7359  
 
 7360  
         }
 7361  0
         catch (RecognitionException re) {
 7362  0
             reportError(re);
 7363  0
             recover(input,re);
 7364  0
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 7365  
 
 7366  
         }
 7367  
 
 7368  0
         finally {
 7369  
                 // do for sure before leaving
 7370  80
         }
 7371  80
         return retval;
 7372  
     }
 7373  
     // $ANTLR end "modify"
 7374  
 
 7375  
 
 7376  66
     public static class deleteClause_return extends ParserRuleReturnScope {
 7377  
         Object tree;
 7378  66
         public Object getTree() { return tree; }
 7379  
     };
 7380  
 
 7381  
 
 7382  
     // $ANTLR start "deleteClause"
 7383  
     // com\\googlecode\\sparkleg\\Sparql.g:241:1: deleteClause : DELETE quadPattern -> ^( DELETE quadPattern ) ;
 7384  
     public final SparqlParser.deleteClause_return deleteClause() throws RecognitionException {
 7385  66
         SparqlParser.deleteClause_return retval = new SparqlParser.deleteClause_return();
 7386  66
         retval.start = input.LT(1);
 7387  
 
 7388  
 
 7389  66
         Object root_0 = null;
 7390  
 
 7391  66
         Token DELETE162=null;
 7392  66
         SparqlParser.quadPattern_return quadPattern163 =null;
 7393  
 
 7394  
 
 7395  66
         Object DELETE162_tree=null;
 7396  66
         RewriteRuleTokenStream stream_DELETE=new RewriteRuleTokenStream(adaptor,"token DELETE");
 7397  66
         RewriteRuleSubtreeStream stream_quadPattern=new RewriteRuleSubtreeStream(adaptor,"rule quadPattern");
 7398  
         try {
 7399  
             // com\\googlecode\\sparkleg\\Sparql.g:242:5: ( DELETE quadPattern -> ^( DELETE quadPattern ) )
 7400  
             // com\\googlecode\\sparkleg\\Sparql.g:242:7: DELETE quadPattern
 7401  
             {
 7402  66
             DELETE162=(Token)match(input,DELETE,FOLLOW_DELETE_in_deleteClause1947);  
 7403  66
             stream_DELETE.add(DELETE162);
 7404  
 
 7405  
 
 7406  66
             pushFollow(FOLLOW_quadPattern_in_deleteClause1949);
 7407  66
             quadPattern163=quadPattern();
 7408  
 
 7409  66
             state._fsp--;
 7410  
 
 7411  66
             stream_quadPattern.add(quadPattern163.getTree());
 7412  
 
 7413  
             // AST REWRITE
 7414  
             // elements: quadPattern, DELETE
 7415  
             // token labels: 
 7416  
             // rule labels: retval
 7417  
             // token list labels: 
 7418  
             // rule list labels: 
 7419  
             // wildcard labels: 
 7420  66
             retval.tree = root_0;
 7421  66
             RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 7422  
 
 7423  66
             root_0 = (Object)adaptor.nil();
 7424  
             // 242:26: -> ^( DELETE quadPattern )
 7425  
             {
 7426  
                 // com\\googlecode\\sparkleg\\Sparql.g:242:29: ^( DELETE quadPattern )
 7427  
                 {
 7428  66
                 Object root_1 = (Object)adaptor.nil();
 7429  66
                 root_1 = (Object)adaptor.becomeRoot(
 7430  
                 stream_DELETE.nextNode()
 7431  
                 , root_1);
 7432  
 
 7433  66
                 adaptor.addChild(root_1, stream_quadPattern.nextTree());
 7434  
 
 7435  66
                 adaptor.addChild(root_0, root_1);
 7436  
                 }
 7437  
 
 7438  
             }
 7439  
 
 7440  
 
 7441  66
             retval.tree = root_0;
 7442  
 
 7443  
             }
 7444  
 
 7445  66
             retval.stop = input.LT(-1);
 7446  
 
 7447  
 
 7448  66
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 7449  66
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 7450  
 
 7451  
         }
 7452  0
         catch (RecognitionException re) {
 7453  0
             reportError(re);
 7454  0
             recover(input,re);
 7455  0
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 7456  
 
 7457  
         }
 7458  
 
 7459  0
         finally {
 7460  
                 // do for sure before leaving
 7461  66
         }
 7462  66
         return retval;
 7463  
     }
 7464  
     // $ANTLR end "deleteClause"
 7465  
 
 7466  
 
 7467  24
     public static class insertClause_return extends ParserRuleReturnScope {
 7468  
         Object tree;
 7469  24
         public Object getTree() { return tree; }
 7470  
     };
 7471  
 
 7472  
 
 7473  
     // $ANTLR start "insertClause"
 7474  
     // com\\googlecode\\sparkleg\\Sparql.g:245:1: insertClause : INSERT quadPattern -> ^( INSERT quadPattern ) ;
 7475  
     public final SparqlParser.insertClause_return insertClause() throws RecognitionException {
 7476  24
         SparqlParser.insertClause_return retval = new SparqlParser.insertClause_return();
 7477  24
         retval.start = input.LT(1);
 7478  
 
 7479  
 
 7480  24
         Object root_0 = null;
 7481  
 
 7482  24
         Token INSERT164=null;
 7483  24
         SparqlParser.quadPattern_return quadPattern165 =null;
 7484  
 
 7485  
 
 7486  24
         Object INSERT164_tree=null;
 7487  24
         RewriteRuleTokenStream stream_INSERT=new RewriteRuleTokenStream(adaptor,"token INSERT");
 7488  24
         RewriteRuleSubtreeStream stream_quadPattern=new RewriteRuleSubtreeStream(adaptor,"rule quadPattern");
 7489  
         try {
 7490  
             // com\\googlecode\\sparkleg\\Sparql.g:246:5: ( INSERT quadPattern -> ^( INSERT quadPattern ) )
 7491  
             // com\\googlecode\\sparkleg\\Sparql.g:246:7: INSERT quadPattern
 7492  
             {
 7493  24
             INSERT164=(Token)match(input,INSERT,FOLLOW_INSERT_in_insertClause1980);  
 7494  24
             stream_INSERT.add(INSERT164);
 7495  
 
 7496  
 
 7497  24
             pushFollow(FOLLOW_quadPattern_in_insertClause1982);
 7498  24
             quadPattern165=quadPattern();
 7499  
 
 7500  24
             state._fsp--;
 7501  
 
 7502  24
             stream_quadPattern.add(quadPattern165.getTree());
 7503  
 
 7504  
             // AST REWRITE
 7505  
             // elements: quadPattern, INSERT
 7506  
             // token labels: 
 7507  
             // rule labels: retval
 7508  
             // token list labels: 
 7509  
             // rule list labels: 
 7510  
             // wildcard labels: 
 7511  24
             retval.tree = root_0;
 7512  24
             RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 7513  
 
 7514  24
             root_0 = (Object)adaptor.nil();
 7515  
             // 246:26: -> ^( INSERT quadPattern )
 7516  
             {
 7517  
                 // com\\googlecode\\sparkleg\\Sparql.g:246:29: ^( INSERT quadPattern )
 7518  
                 {
 7519  24
                 Object root_1 = (Object)adaptor.nil();
 7520  24
                 root_1 = (Object)adaptor.becomeRoot(
 7521  
                 stream_INSERT.nextNode()
 7522  
                 , root_1);
 7523  
 
 7524  24
                 adaptor.addChild(root_1, stream_quadPattern.nextTree());
 7525  
 
 7526  24
                 adaptor.addChild(root_0, root_1);
 7527  
                 }
 7528  
 
 7529  
             }
 7530  
 
 7531  
 
 7532  24
             retval.tree = root_0;
 7533  
 
 7534  
             }
 7535  
 
 7536  24
             retval.stop = input.LT(-1);
 7537  
 
 7538  
 
 7539  24
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 7540  24
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 7541  
 
 7542  
         }
 7543  0
         catch (RecognitionException re) {
 7544  0
             reportError(re);
 7545  0
             recover(input,re);
 7546  0
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 7547  
 
 7548  
         }
 7549  
 
 7550  0
         finally {
 7551  
                 // do for sure before leaving
 7552  24
         }
 7553  24
         return retval;
 7554  
     }
 7555  
     // $ANTLR end "insertClause"
 7556  
 
 7557  
 
 7558  15
     public static class usingClause_return extends ParserRuleReturnScope {
 7559  
         Object tree;
 7560  15
         public Object getTree() { return tree; }
 7561  
     };
 7562  
 
 7563  
 
 7564  
     // $ANTLR start "usingClause"
 7565  
     // com\\googlecode\\sparkleg\\Sparql.g:249:1: usingClause : USING ( NAMED )? iriRef -> ^( USING ( NAMED )? iriRef ) ;
 7566  
     public final SparqlParser.usingClause_return usingClause() throws RecognitionException {
 7567  15
         SparqlParser.usingClause_return retval = new SparqlParser.usingClause_return();
 7568  15
         retval.start = input.LT(1);
 7569  
 
 7570  
 
 7571  15
         Object root_0 = null;
 7572  
 
 7573  15
         Token USING166=null;
 7574  15
         Token NAMED167=null;
 7575  15
         SparqlParser.iriRef_return iriRef168 =null;
 7576  
 
 7577  
 
 7578  15
         Object USING166_tree=null;
 7579  15
         Object NAMED167_tree=null;
 7580  15
         RewriteRuleTokenStream stream_USING=new RewriteRuleTokenStream(adaptor,"token USING");
 7581  15
         RewriteRuleTokenStream stream_NAMED=new RewriteRuleTokenStream(adaptor,"token NAMED");
 7582  15
         RewriteRuleSubtreeStream stream_iriRef=new RewriteRuleSubtreeStream(adaptor,"rule iriRef");
 7583  
         try {
 7584  
             // com\\googlecode\\sparkleg\\Sparql.g:250:5: ( USING ( NAMED )? iriRef -> ^( USING ( NAMED )? iriRef ) )
 7585  
             // com\\googlecode\\sparkleg\\Sparql.g:250:7: USING ( NAMED )? iriRef
 7586  
             {
 7587  15
             USING166=(Token)match(input,USING,FOLLOW_USING_in_usingClause2007);  
 7588  15
             stream_USING.add(USING166);
 7589  
 
 7590  
 
 7591  
             // com\\googlecode\\sparkleg\\Sparql.g:250:13: ( NAMED )?
 7592  15
             int alt54=2;
 7593  15
             switch ( input.LA(1) ) {
 7594  
                 case NAMED:
 7595  
                     {
 7596  0
                     alt54=1;
 7597  
                     }
 7598  
                     break;
 7599  
             }
 7600  
 
 7601  15
             switch (alt54) {
 7602  
                 case 1 :
 7603  
                     // com\\googlecode\\sparkleg\\Sparql.g:250:13: NAMED
 7604  
                     {
 7605  0
                     NAMED167=(Token)match(input,NAMED,FOLLOW_NAMED_in_usingClause2009);  
 7606  0
                     stream_NAMED.add(NAMED167);
 7607  
 
 7608  
 
 7609  
                     }
 7610  
                     break;
 7611  
 
 7612  
             }
 7613  
 
 7614  
 
 7615  15
             pushFollow(FOLLOW_iriRef_in_usingClause2012);
 7616  15
             iriRef168=iriRef();
 7617  
 
 7618  15
             state._fsp--;
 7619  
 
 7620  15
             stream_iriRef.add(iriRef168.getTree());
 7621  
 
 7622  
             // AST REWRITE
 7623  
             // elements: iriRef, USING, NAMED
 7624  
             // token labels: 
 7625  
             // rule labels: retval
 7626  
             // token list labels: 
 7627  
             // rule list labels: 
 7628  
             // wildcard labels: 
 7629  15
             retval.tree = root_0;
 7630  15
             RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 7631  
 
 7632  15
             root_0 = (Object)adaptor.nil();
 7633  
             // 250:27: -> ^( USING ( NAMED )? iriRef )
 7634  
             {
 7635  
                 // com\\googlecode\\sparkleg\\Sparql.g:250:30: ^( USING ( NAMED )? iriRef )
 7636  
                 {
 7637  15
                 Object root_1 = (Object)adaptor.nil();
 7638  15
                 root_1 = (Object)adaptor.becomeRoot(
 7639  
                 stream_USING.nextNode()
 7640  
                 , root_1);
 7641  
 
 7642  
                 // com\\googlecode\\sparkleg\\Sparql.g:250:38: ( NAMED )?
 7643  15
                 if ( stream_NAMED.hasNext() ) {
 7644  0
                     adaptor.addChild(root_1, 
 7645  
                     stream_NAMED.nextNode()
 7646  
                     );
 7647  
 
 7648  
                 }
 7649  15
                 stream_NAMED.reset();
 7650  
 
 7651  15
                 adaptor.addChild(root_1, stream_iriRef.nextTree());
 7652  
 
 7653  15
                 adaptor.addChild(root_0, root_1);
 7654  
                 }
 7655  
 
 7656  
             }
 7657  
 
 7658  
 
 7659  15
             retval.tree = root_0;
 7660  
 
 7661  
             }
 7662  
 
 7663  15
             retval.stop = input.LT(-1);
 7664  
 
 7665  
 
 7666  15
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 7667  15
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 7668  
 
 7669  
         }
 7670  0
         catch (RecognitionException re) {
 7671  0
             reportError(re);
 7672  0
             recover(input,re);
 7673  0
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 7674  
 
 7675  
         }
 7676  
 
 7677  0
         finally {
 7678  
                 // do for sure before leaving
 7679  15
         }
 7680  15
         return retval;
 7681  
     }
 7682  
     // $ANTLR end "usingClause"
 7683  
 
 7684  
 
 7685  0
     public static class graphOrDefault_return extends ParserRuleReturnScope {
 7686  
         Object tree;
 7687  0
         public Object getTree() { return tree; }
 7688  
     };
 7689  
 
 7690  
 
 7691  
     // $ANTLR start "graphOrDefault"
 7692  
     // com\\googlecode\\sparkleg\\Sparql.g:253:1: graphOrDefault : ( DEFAULT | ( GRAPH )? iriRef );
 7693  
     public final SparqlParser.graphOrDefault_return graphOrDefault() throws RecognitionException {
 7694  0
         SparqlParser.graphOrDefault_return retval = new SparqlParser.graphOrDefault_return();
 7695  0
         retval.start = input.LT(1);
 7696  
 
 7697  
 
 7698  0
         Object root_0 = null;
 7699  
 
 7700  0
         Token DEFAULT169=null;
 7701  0
         Token GRAPH170=null;
 7702  0
         SparqlParser.iriRef_return iriRef171 =null;
 7703  
 
 7704  
 
 7705  0
         Object DEFAULT169_tree=null;
 7706  0
         Object GRAPH170_tree=null;
 7707  
 
 7708  
         try {
 7709  
             // com\\googlecode\\sparkleg\\Sparql.g:254:5: ( DEFAULT | ( GRAPH )? iriRef )
 7710  0
             int alt56=2;
 7711  0
             switch ( input.LA(1) ) {
 7712  
             case DEFAULT:
 7713  
                 {
 7714  0
                 alt56=1;
 7715  
                 }
 7716  0
                 break;
 7717  
             case GRAPH:
 7718  
             case IRI_REF:
 7719  
             case PNAME_LN:
 7720  
             case PNAME_NS:
 7721  
                 {
 7722  0
                 alt56=2;
 7723  
                 }
 7724  0
                 break;
 7725  
             default:
 7726  0
                 NoViableAltException nvae =
 7727  
                     new NoViableAltException("", 56, 0, input);
 7728  
 
 7729  0
                 throw nvae;
 7730  
 
 7731  
             }
 7732  
 
 7733  0
             switch (alt56) {
 7734  
                 case 1 :
 7735  
                     // com\\googlecode\\sparkleg\\Sparql.g:254:7: DEFAULT
 7736  
                     {
 7737  0
                     root_0 = (Object)adaptor.nil();
 7738  
 
 7739  
 
 7740  0
                     DEFAULT169=(Token)match(input,DEFAULT,FOLLOW_DEFAULT_in_graphOrDefault2043); 
 7741  0
                     DEFAULT169_tree = 
 7742  
                     (Object)adaptor.create(DEFAULT169)
 7743  
                     ;
 7744  0
                     adaptor.addChild(root_0, DEFAULT169_tree);
 7745  
 
 7746  
 
 7747  
                     }
 7748  0
                     break;
 7749  
                 case 2 :
 7750  
                     // com\\googlecode\\sparkleg\\Sparql.g:255:7: ( GRAPH )? iriRef
 7751  
                     {
 7752  0
                     root_0 = (Object)adaptor.nil();
 7753  
 
 7754  
 
 7755  
                     // com\\googlecode\\sparkleg\\Sparql.g:255:7: ( GRAPH )?
 7756  0
                     int alt55=2;
 7757  0
                     switch ( input.LA(1) ) {
 7758  
                         case GRAPH:
 7759  
                             {
 7760  0
                             alt55=1;
 7761  
                             }
 7762  
                             break;
 7763  
                     }
 7764  
 
 7765  0
                     switch (alt55) {
 7766  
                         case 1 :
 7767  
                             // com\\googlecode\\sparkleg\\Sparql.g:255:7: GRAPH
 7768  
                             {
 7769  0
                             GRAPH170=(Token)match(input,GRAPH,FOLLOW_GRAPH_in_graphOrDefault2052); 
 7770  0
                             GRAPH170_tree = 
 7771  
                             (Object)adaptor.create(GRAPH170)
 7772  
                             ;
 7773  0
                             adaptor.addChild(root_0, GRAPH170_tree);
 7774  
 
 7775  
 
 7776  
                             }
 7777  
                             break;
 7778  
 
 7779  
                     }
 7780  
 
 7781  
 
 7782  0
                     pushFollow(FOLLOW_iriRef_in_graphOrDefault2055);
 7783  0
                     iriRef171=iriRef();
 7784  
 
 7785  0
                     state._fsp--;
 7786  
 
 7787  0
                     adaptor.addChild(root_0, iriRef171.getTree());
 7788  
 
 7789  
                     }
 7790  
                     break;
 7791  
 
 7792  
             }
 7793  0
             retval.stop = input.LT(-1);
 7794  
 
 7795  
 
 7796  0
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 7797  0
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 7798  
 
 7799  
         }
 7800  0
         catch (RecognitionException re) {
 7801  0
             reportError(re);
 7802  0
             recover(input,re);
 7803  0
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 7804  
 
 7805  
         }
 7806  
 
 7807  0
         finally {
 7808  
                 // do for sure before leaving
 7809  0
         }
 7810  0
         return retval;
 7811  
     }
 7812  
     // $ANTLR end "graphOrDefault"
 7813  
 
 7814  
 
 7815  4
     public static class graphRef_return extends ParserRuleReturnScope {
 7816  
         Object tree;
 7817  4
         public Object getTree() { return tree; }
 7818  
     };
 7819  
 
 7820  
 
 7821  
     // $ANTLR start "graphRef"
 7822  
     // com\\googlecode\\sparkleg\\Sparql.g:258:1: graphRef : GRAPH iriRef ;
 7823  
     public final SparqlParser.graphRef_return graphRef() throws RecognitionException {
 7824  4
         SparqlParser.graphRef_return retval = new SparqlParser.graphRef_return();
 7825  4
         retval.start = input.LT(1);
 7826  
 
 7827  
 
 7828  4
         Object root_0 = null;
 7829  
 
 7830  4
         Token GRAPH172=null;
 7831  4
         SparqlParser.iriRef_return iriRef173 =null;
 7832  
 
 7833  
 
 7834  4
         Object GRAPH172_tree=null;
 7835  
 
 7836  
         try {
 7837  
             // com\\googlecode\\sparkleg\\Sparql.g:259:5: ( GRAPH iriRef )
 7838  
             // com\\googlecode\\sparkleg\\Sparql.g:259:7: GRAPH iriRef
 7839  
             {
 7840  4
             root_0 = (Object)adaptor.nil();
 7841  
 
 7842  
 
 7843  4
             GRAPH172=(Token)match(input,GRAPH,FOLLOW_GRAPH_in_graphRef2082); 
 7844  4
             GRAPH172_tree = 
 7845  
             (Object)adaptor.create(GRAPH172)
 7846  
             ;
 7847  4
             adaptor.addChild(root_0, GRAPH172_tree);
 7848  
 
 7849  
 
 7850  4
             pushFollow(FOLLOW_iriRef_in_graphRef2084);
 7851  4
             iriRef173=iriRef();
 7852  
 
 7853  4
             state._fsp--;
 7854  
 
 7855  4
             adaptor.addChild(root_0, iriRef173.getTree());
 7856  
 
 7857  
             }
 7858  
 
 7859  4
             retval.stop = input.LT(-1);
 7860  
 
 7861  
 
 7862  4
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 7863  4
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 7864  
 
 7865  
         }
 7866  0
         catch (RecognitionException re) {
 7867  0
             reportError(re);
 7868  0
             recover(input,re);
 7869  0
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 7870  
 
 7871  
         }
 7872  
 
 7873  0
         finally {
 7874  
                 // do for sure before leaving
 7875  4
         }
 7876  4
         return retval;
 7877  
     }
 7878  
     // $ANTLR end "graphRef"
 7879  
 
 7880  
 
 7881  16
     public static class graphRefAll_return extends ParserRuleReturnScope {
 7882  
         Object tree;
 7883  16
         public Object getTree() { return tree; }
 7884  
     };
 7885  
 
 7886  
 
 7887  
     // $ANTLR start "graphRefAll"
 7888  
     // com\\googlecode\\sparkleg\\Sparql.g:262:1: graphRefAll : ( graphRef | DEFAULT | NAMED | ALL );
 7889  
     public final SparqlParser.graphRefAll_return graphRefAll() throws RecognitionException {
 7890  16
         SparqlParser.graphRefAll_return retval = new SparqlParser.graphRefAll_return();
 7891  16
         retval.start = input.LT(1);
 7892  
 
 7893  
 
 7894  16
         Object root_0 = null;
 7895  
 
 7896  16
         Token DEFAULT175=null;
 7897  16
         Token NAMED176=null;
 7898  16
         Token ALL177=null;
 7899  16
         SparqlParser.graphRef_return graphRef174 =null;
 7900  
 
 7901  
 
 7902  16
         Object DEFAULT175_tree=null;
 7903  16
         Object NAMED176_tree=null;
 7904  16
         Object ALL177_tree=null;
 7905  
 
 7906  
         try {
 7907  
             // com\\googlecode\\sparkleg\\Sparql.g:263:5: ( graphRef | DEFAULT | NAMED | ALL )
 7908  16
             int alt57=4;
 7909  16
             switch ( input.LA(1) ) {
 7910  
             case GRAPH:
 7911  
                 {
 7912  4
                 alt57=1;
 7913  
                 }
 7914  4
                 break;
 7915  
             case DEFAULT:
 7916  
                 {
 7917  4
                 alt57=2;
 7918  
                 }
 7919  4
                 break;
 7920  
             case NAMED:
 7921  
                 {
 7922  4
                 alt57=3;
 7923  
                 }
 7924  4
                 break;
 7925  
             case ALL:
 7926  
                 {
 7927  4
                 alt57=4;
 7928  
                 }
 7929  4
                 break;
 7930  
             default:
 7931  0
                 NoViableAltException nvae =
 7932  
                     new NoViableAltException("", 57, 0, input);
 7933  
 
 7934  0
                 throw nvae;
 7935  
 
 7936  
             }
 7937  
 
 7938  16
             switch (alt57) {
 7939  
                 case 1 :
 7940  
                     // com\\googlecode\\sparkleg\\Sparql.g:263:7: graphRef
 7941  
                     {
 7942  4
                     root_0 = (Object)adaptor.nil();
 7943  
 
 7944  
 
 7945  4
                     pushFollow(FOLLOW_graphRef_in_graphRefAll2101);
 7946  4
                     graphRef174=graphRef();
 7947  
 
 7948  4
                     state._fsp--;
 7949  
 
 7950  4
                     adaptor.addChild(root_0, graphRef174.getTree());
 7951  
 
 7952  
                     }
 7953  4
                     break;
 7954  
                 case 2 :
 7955  
                     // com\\googlecode\\sparkleg\\Sparql.g:263:18: DEFAULT
 7956  
                     {
 7957  4
                     root_0 = (Object)adaptor.nil();
 7958  
 
 7959  
 
 7960  4
                     DEFAULT175=(Token)match(input,DEFAULT,FOLLOW_DEFAULT_in_graphRefAll2105); 
 7961  4
                     DEFAULT175_tree = 
 7962  
                     (Object)adaptor.create(DEFAULT175)
 7963  
                     ;
 7964  4
                     adaptor.addChild(root_0, DEFAULT175_tree);
 7965  
 
 7966  
 
 7967  
                     }
 7968  4
                     break;
 7969  
                 case 3 :
 7970  
                     // com\\googlecode\\sparkleg\\Sparql.g:263:28: NAMED
 7971  
                     {
 7972  4
                     root_0 = (Object)adaptor.nil();
 7973  
 
 7974  
 
 7975  4
                     NAMED176=(Token)match(input,NAMED,FOLLOW_NAMED_in_graphRefAll2109); 
 7976  4
                     NAMED176_tree = 
 7977  
                     (Object)adaptor.create(NAMED176)
 7978  
                     ;
 7979  4
                     adaptor.addChild(root_0, NAMED176_tree);
 7980  
 
 7981  
 
 7982  
                     }
 7983  4
                     break;
 7984  
                 case 4 :
 7985  
                     // com\\googlecode\\sparkleg\\Sparql.g:263:36: ALL
 7986  
                     {
 7987  4
                     root_0 = (Object)adaptor.nil();
 7988  
 
 7989  
 
 7990  4
                     ALL177=(Token)match(input,ALL,FOLLOW_ALL_in_graphRefAll2113); 
 7991  4
                     ALL177_tree = 
 7992  
                     (Object)adaptor.create(ALL177)
 7993  
                     ;
 7994  4
                     adaptor.addChild(root_0, ALL177_tree);
 7995  
 
 7996  
 
 7997  
                     }
 7998  
                     break;
 7999  
 
 8000  
             }
 8001  16
             retval.stop = input.LT(-1);
 8002  
 
 8003  
 
 8004  16
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 8005  16
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 8006  
 
 8007  
         }
 8008  0
         catch (RecognitionException re) {
 8009  0
             reportError(re);
 8010  0
             recover(input,re);
 8011  0
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 8012  
 
 8013  
         }
 8014  
 
 8015  0
         finally {
 8016  
                 // do for sure before leaving
 8017  16
         }
 8018  16
         return retval;
 8019  
     }
 8020  
     // $ANTLR end "graphRefAll"
 8021  
 
 8022  
 
 8023  122
     public static class quadPattern_return extends ParserRuleReturnScope {
 8024  
         Object tree;
 8025  122
         public Object getTree() { return tree; }
 8026  
     };
 8027  
 
 8028  
 
 8029  
     // $ANTLR start "quadPattern"
 8030  
     // com\\googlecode\\sparkleg\\Sparql.g:266:1: quadPattern : OPEN_CURLY_BRACE quads CLOSE_CURLY_BRACE -> quads ;
 8031  
     public final SparqlParser.quadPattern_return quadPattern() throws RecognitionException {
 8032  122
         SparqlParser.quadPattern_return retval = new SparqlParser.quadPattern_return();
 8033  122
         retval.start = input.LT(1);
 8034  
 
 8035  
 
 8036  122
         Object root_0 = null;
 8037  
 
 8038  122
         Token OPEN_CURLY_BRACE178=null;
 8039  122
         Token CLOSE_CURLY_BRACE180=null;
 8040  122
         SparqlParser.quads_return quads179 =null;
 8041  
 
 8042  
 
 8043  122
         Object OPEN_CURLY_BRACE178_tree=null;
 8044  122
         Object CLOSE_CURLY_BRACE180_tree=null;
 8045  122
         RewriteRuleTokenStream stream_OPEN_CURLY_BRACE=new RewriteRuleTokenStream(adaptor,"token OPEN_CURLY_BRACE");
 8046  122
         RewriteRuleTokenStream stream_CLOSE_CURLY_BRACE=new RewriteRuleTokenStream(adaptor,"token CLOSE_CURLY_BRACE");
 8047  122
         RewriteRuleSubtreeStream stream_quads=new RewriteRuleSubtreeStream(adaptor,"rule quads");
 8048  
         try {
 8049  
             // com\\googlecode\\sparkleg\\Sparql.g:267:5: ( OPEN_CURLY_BRACE quads CLOSE_CURLY_BRACE -> quads )
 8050  
             // com\\googlecode\\sparkleg\\Sparql.g:267:7: OPEN_CURLY_BRACE quads CLOSE_CURLY_BRACE
 8051  
             {
 8052  122
             OPEN_CURLY_BRACE178=(Token)match(input,OPEN_CURLY_BRACE,FOLLOW_OPEN_CURLY_BRACE_in_quadPattern2130);  
 8053  122
             stream_OPEN_CURLY_BRACE.add(OPEN_CURLY_BRACE178);
 8054  
 
 8055  
 
 8056  122
             pushFollow(FOLLOW_quads_in_quadPattern2132);
 8057  122
             quads179=quads();
 8058  
 
 8059  122
             state._fsp--;
 8060  
 
 8061  122
             stream_quads.add(quads179.getTree());
 8062  
 
 8063  122
             CLOSE_CURLY_BRACE180=(Token)match(input,CLOSE_CURLY_BRACE,FOLLOW_CLOSE_CURLY_BRACE_in_quadPattern2134);  
 8064  122
             stream_CLOSE_CURLY_BRACE.add(CLOSE_CURLY_BRACE180);
 8065  
 
 8066  
 
 8067  
             // AST REWRITE
 8068  
             // elements: quads
 8069  
             // token labels: 
 8070  
             // rule labels: retval
 8071  
             // token list labels: 
 8072  
             // rule list labels: 
 8073  
             // wildcard labels: 
 8074  122
             retval.tree = root_0;
 8075  122
             RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 8076  
 
 8077  122
             root_0 = (Object)adaptor.nil();
 8078  
             // 267:48: -> quads
 8079  
             {
 8080  122
                 adaptor.addChild(root_0, stream_quads.nextTree());
 8081  
 
 8082  
             }
 8083  
 
 8084  
 
 8085  122
             retval.tree = root_0;
 8086  
 
 8087  
             }
 8088  
 
 8089  122
             retval.stop = input.LT(-1);
 8090  
 
 8091  
 
 8092  122
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 8093  122
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 8094  
 
 8095  
         }
 8096  0
         catch (RecognitionException re) {
 8097  0
             reportError(re);
 8098  0
             recover(input,re);
 8099  0
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 8100  
 
 8101  
         }
 8102  
 
 8103  0
         finally {
 8104  
                 // do for sure before leaving
 8105  122
         }
 8106  122
         return retval;
 8107  
     }
 8108  
     // $ANTLR end "quadPattern"
 8109  
 
 8110  
 
 8111  122
     public static class quads_return extends ParserRuleReturnScope {
 8112  
         Object tree;
 8113  122
         public Object getTree() { return tree; }
 8114  
     };
 8115  
 
 8116  
 
 8117  
     // $ANTLR start "quads"
 8118  
     // com\\googlecode\\sparkleg\\Sparql.g:270:1: quads : ( triplesTemplate )? ( quadsDetails )* -> ( triplesTemplate )? ( quadsDetails )* ;
 8119  
     public final SparqlParser.quads_return quads() throws RecognitionException {
 8120  122
         SparqlParser.quads_return retval = new SparqlParser.quads_return();
 8121  122
         retval.start = input.LT(1);
 8122  
 
 8123  
 
 8124  122
         Object root_0 = null;
 8125  
 
 8126  122
         SparqlParser.triplesTemplate_return triplesTemplate181 =null;
 8127  
 
 8128  122
         SparqlParser.quadsDetails_return quadsDetails182 =null;
 8129  
 
 8130  
 
 8131  122
         RewriteRuleSubtreeStream stream_triplesTemplate=new RewriteRuleSubtreeStream(adaptor,"rule triplesTemplate");
 8132  122
         RewriteRuleSubtreeStream stream_quadsDetails=new RewriteRuleSubtreeStream(adaptor,"rule quadsDetails");
 8133  
         try {
 8134  
             // com\\googlecode\\sparkleg\\Sparql.g:271:5: ( ( triplesTemplate )? ( quadsDetails )* -> ( triplesTemplate )? ( quadsDetails )* )
 8135  
             // com\\googlecode\\sparkleg\\Sparql.g:271:7: ( triplesTemplate )? ( quadsDetails )*
 8136  
             {
 8137  
             // com\\googlecode\\sparkleg\\Sparql.g:271:7: ( triplesTemplate )?
 8138  122
             int alt58=2;
 8139  122
             switch ( input.LA(1) ) {
 8140  
                 case BLANK_NODE_LABEL:
 8141  
                 case DECIMAL:
 8142  
                 case DECIMAL_NEGATIVE:
 8143  
                 case DECIMAL_POSITIVE:
 8144  
                 case DOUBLE:
 8145  
                 case DOUBLE_NEGATIVE:
 8146  
                 case DOUBLE_POSITIVE:
 8147  
                 case FALSE:
 8148  
                 case INTEGER:
 8149  
                 case INTEGER_NEGATIVE:
 8150  
                 case INTEGER_POSITIVE:
 8151  
                 case IRI_REF:
 8152  
                 case OPEN_BRACE:
 8153  
                 case OPEN_SQUARE_BRACKET:
 8154  
                 case PNAME_LN:
 8155  
                 case PNAME_NS:
 8156  
                 case STRING_LITERAL1:
 8157  
                 case STRING_LITERAL2:
 8158  
                 case STRING_LITERAL_LONG1:
 8159  
                 case STRING_LITERAL_LONG2:
 8160  
                 case TRUE:
 8161  
                 case VAR1:
 8162  
                 case VAR2:
 8163  
                     {
 8164  88
                     alt58=1;
 8165  
                     }
 8166  
                     break;
 8167  
             }
 8168  
 
 8169  122
             switch (alt58) {
 8170  
                 case 1 :
 8171  
                     // com\\googlecode\\sparkleg\\Sparql.g:271:7: triplesTemplate
 8172  
                     {
 8173  88
                     pushFollow(FOLLOW_triplesTemplate_in_quads2159);
 8174  88
                     triplesTemplate181=triplesTemplate();
 8175  
 
 8176  88
                     state._fsp--;
 8177  
 
 8178  88
                     stream_triplesTemplate.add(triplesTemplate181.getTree());
 8179  
 
 8180  
                     }
 8181  
                     break;
 8182  
 
 8183  
             }
 8184  
 
 8185  
 
 8186  
             // com\\googlecode\\sparkleg\\Sparql.g:271:24: ( quadsDetails )*
 8187  
             loop59:
 8188  
             do {
 8189  156
                 int alt59=2;
 8190  156
                 switch ( input.LA(1) ) {
 8191  
                 case GRAPH:
 8192  
                     {
 8193  34
                     alt59=1;
 8194  
                     }
 8195  
                     break;
 8196  
 
 8197  
                 }
 8198  
 
 8199  156
                 switch (alt59) {
 8200  
                     case 1 :
 8201  
                         // com\\googlecode\\sparkleg\\Sparql.g:271:24: quadsDetails
 8202  
                         {
 8203  34
                         pushFollow(FOLLOW_quadsDetails_in_quads2162);
 8204  34
                         quadsDetails182=quadsDetails();
 8205  
 
 8206  34
                         state._fsp--;
 8207  
 
 8208  34
                         stream_quadsDetails.add(quadsDetails182.getTree());
 8209  
 
 8210  
                         }
 8211  34
                         break;
 8212  
 
 8213  
                     default :
 8214  122
                         break loop59;
 8215  
                 }
 8216  34
             } while (true);
 8217  
 
 8218  
 
 8219  
             // AST REWRITE
 8220  
             // elements: quadsDetails, triplesTemplate
 8221  
             // token labels: 
 8222  
             // rule labels: retval
 8223  
             // token list labels: 
 8224  
             // rule list labels: 
 8225  
             // wildcard labels: 
 8226  122
             retval.tree = root_0;
 8227  122
             RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 8228  
 
 8229  122
             root_0 = (Object)adaptor.nil();
 8230  
             // 271:38: -> ( triplesTemplate )? ( quadsDetails )*
 8231  
             {
 8232  
                 // com\\googlecode\\sparkleg\\Sparql.g:271:42: ( triplesTemplate )?
 8233  122
                 if ( stream_triplesTemplate.hasNext() ) {
 8234  88
                     adaptor.addChild(root_0, stream_triplesTemplate.nextTree());
 8235  
 
 8236  
                 }
 8237  122
                 stream_triplesTemplate.reset();
 8238  
 
 8239  
                 // com\\googlecode\\sparkleg\\Sparql.g:271:59: ( quadsDetails )*
 8240  156
                 while ( stream_quadsDetails.hasNext() ) {
 8241  34
                     adaptor.addChild(root_0, stream_quadsDetails.nextTree());
 8242  
 
 8243  
                 }
 8244  122
                 stream_quadsDetails.reset();
 8245  
 
 8246  
             }
 8247  
 
 8248  
 
 8249  122
             retval.tree = root_0;
 8250  
 
 8251  
             }
 8252  
 
 8253  122
             retval.stop = input.LT(-1);
 8254  
 
 8255  
 
 8256  122
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 8257  122
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 8258  
 
 8259  
         }
 8260  0
         catch (RecognitionException re) {
 8261  0
             reportError(re);
 8262  0
             recover(input,re);
 8263  0
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 8264  
 
 8265  
         }
 8266  
 
 8267  0
         finally {
 8268  
                 // do for sure before leaving
 8269  122
         }
 8270  122
         return retval;
 8271  
     }
 8272  
     // $ANTLR end "quads"
 8273  
 
 8274  
 
 8275  34
     public static class quadsDetails_return extends ParserRuleReturnScope {
 8276  
         Object tree;
 8277  34
         public Object getTree() { return tree; }
 8278  
     };
 8279  
 
 8280  
 
 8281  
     // $ANTLR start "quadsDetails"
 8282  
     // com\\googlecode\\sparkleg\\Sparql.g:274:1: quadsDetails : quadsNotTriples ( DOT )? ( triplesTemplate )? -> quadsNotTriples ( triplesTemplate )? ;
 8283  
     public final SparqlParser.quadsDetails_return quadsDetails() throws RecognitionException {
 8284  34
         SparqlParser.quadsDetails_return retval = new SparqlParser.quadsDetails_return();
 8285  34
         retval.start = input.LT(1);
 8286  
 
 8287  
 
 8288  34
         Object root_0 = null;
 8289  
 
 8290  34
         Token DOT184=null;
 8291  34
         SparqlParser.quadsNotTriples_return quadsNotTriples183 =null;
 8292  
 
 8293  34
         SparqlParser.triplesTemplate_return triplesTemplate185 =null;
 8294  
 
 8295  
 
 8296  34
         Object DOT184_tree=null;
 8297  34
         RewriteRuleTokenStream stream_DOT=new RewriteRuleTokenStream(adaptor,"token DOT");
 8298  34
         RewriteRuleSubtreeStream stream_triplesTemplate=new RewriteRuleSubtreeStream(adaptor,"rule triplesTemplate");
 8299  34
         RewriteRuleSubtreeStream stream_quadsNotTriples=new RewriteRuleSubtreeStream(adaptor,"rule quadsNotTriples");
 8300  
         try {
 8301  
             // com\\googlecode\\sparkleg\\Sparql.g:275:5: ( quadsNotTriples ( DOT )? ( triplesTemplate )? -> quadsNotTriples ( triplesTemplate )? )
 8302  
             // com\\googlecode\\sparkleg\\Sparql.g:275:7: quadsNotTriples ( DOT )? ( triplesTemplate )?
 8303  
             {
 8304  34
             pushFollow(FOLLOW_quadsNotTriples_in_quadsDetails2194);
 8305  34
             quadsNotTriples183=quadsNotTriples();
 8306  
 
 8307  34
             state._fsp--;
 8308  
 
 8309  34
             stream_quadsNotTriples.add(quadsNotTriples183.getTree());
 8310  
 
 8311  
             // com\\googlecode\\sparkleg\\Sparql.g:275:23: ( DOT )?
 8312  34
             int alt60=2;
 8313  34
             switch ( input.LA(1) ) {
 8314  
                 case DOT:
 8315  
                     {
 8316  0
                     alt60=1;
 8317  
                     }
 8318  
                     break;
 8319  
             }
 8320  
 
 8321  34
             switch (alt60) {
 8322  
                 case 1 :
 8323  
                     // com\\googlecode\\sparkleg\\Sparql.g:275:23: DOT
 8324  
                     {
 8325  0
                     DOT184=(Token)match(input,DOT,FOLLOW_DOT_in_quadsDetails2196);  
 8326  0
                     stream_DOT.add(DOT184);
 8327  
 
 8328  
 
 8329  
                     }
 8330  
                     break;
 8331  
 
 8332  
             }
 8333  
 
 8334  
 
 8335  
             // com\\googlecode\\sparkleg\\Sparql.g:275:28: ( triplesTemplate )?
 8336  34
             int alt61=2;
 8337  34
             switch ( input.LA(1) ) {
 8338  
                 case BLANK_NODE_LABEL:
 8339  
                 case DECIMAL:
 8340  
                 case DECIMAL_NEGATIVE:
 8341  
                 case DECIMAL_POSITIVE:
 8342  
                 case DOUBLE:
 8343  
                 case DOUBLE_NEGATIVE:
 8344  
                 case DOUBLE_POSITIVE:
 8345  
                 case FALSE:
 8346  
                 case INTEGER:
 8347  
                 case INTEGER_NEGATIVE:
 8348  
                 case INTEGER_POSITIVE:
 8349  
                 case IRI_REF:
 8350  
                 case OPEN_BRACE:
 8351  
                 case OPEN_SQUARE_BRACKET:
 8352  
                 case PNAME_LN:
 8353  
                 case PNAME_NS:
 8354  
                 case STRING_LITERAL1:
 8355  
                 case STRING_LITERAL2:
 8356  
                 case STRING_LITERAL_LONG1:
 8357  
                 case STRING_LITERAL_LONG2:
 8358  
                 case TRUE:
 8359  
                 case VAR1:
 8360  
                 case VAR2:
 8361  
                     {
 8362  0
                     alt61=1;
 8363  
                     }
 8364  
                     break;
 8365  
             }
 8366  
 
 8367  34
             switch (alt61) {
 8368  
                 case 1 :
 8369  
                     // com\\googlecode\\sparkleg\\Sparql.g:275:28: triplesTemplate
 8370  
                     {
 8371  0
                     pushFollow(FOLLOW_triplesTemplate_in_quadsDetails2199);
 8372  0
                     triplesTemplate185=triplesTemplate();
 8373  
 
 8374  0
                     state._fsp--;
 8375  
 
 8376  0
                     stream_triplesTemplate.add(triplesTemplate185.getTree());
 8377  
 
 8378  
                     }
 8379  
                     break;
 8380  
 
 8381  
             }
 8382  
 
 8383  
 
 8384  
             // AST REWRITE
 8385  
             // elements: triplesTemplate, quadsNotTriples
 8386  
             // token labels: 
 8387  
             // rule labels: retval
 8388  
             // token list labels: 
 8389  
             // rule list labels: 
 8390  
             // wildcard labels: 
 8391  34
             retval.tree = root_0;
 8392  34
             RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 8393  
 
 8394  34
             root_0 = (Object)adaptor.nil();
 8395  
             // 275:45: -> quadsNotTriples ( triplesTemplate )?
 8396  
             {
 8397  34
                 adaptor.addChild(root_0, stream_quadsNotTriples.nextTree());
 8398  
 
 8399  
                 // com\\googlecode\\sparkleg\\Sparql.g:275:64: ( triplesTemplate )?
 8400  34
                 if ( stream_triplesTemplate.hasNext() ) {
 8401  0
                     adaptor.addChild(root_0, stream_triplesTemplate.nextTree());
 8402  
 
 8403  
                 }
 8404  34
                 stream_triplesTemplate.reset();
 8405  
 
 8406  
             }
 8407  
 
 8408  
 
 8409  34
             retval.tree = root_0;
 8410  
 
 8411  
             }
 8412  
 
 8413  34
             retval.stop = input.LT(-1);
 8414  
 
 8415  
 
 8416  34
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 8417  34
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 8418  
 
 8419  
         }
 8420  0
         catch (RecognitionException re) {
 8421  0
             reportError(re);
 8422  0
             recover(input,re);
 8423  0
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 8424  
 
 8425  
         }
 8426  
 
 8427  0
         finally {
 8428  
                 // do for sure before leaving
 8429  34
         }
 8430  34
         return retval;
 8431  
     }
 8432  
     // $ANTLR end "quadsDetails"
 8433  
 
 8434  
 
 8435  34
     public static class quadsNotTriples_return extends ParserRuleReturnScope {
 8436  
         Object tree;
 8437  34
         public Object getTree() { return tree; }
 8438  
     };
 8439  
 
 8440  
 
 8441  
     // $ANTLR start "quadsNotTriples"
 8442  
     // com\\googlecode\\sparkleg\\Sparql.g:278:1: quadsNotTriples : GRAPH varOrIRIref OPEN_CURLY_BRACE ( triplesTemplate )? CLOSE_CURLY_BRACE -> ^( GRAPH varOrIRIref ( triplesTemplate )? ) ;
 8443  
     public final SparqlParser.quadsNotTriples_return quadsNotTriples() throws RecognitionException {
 8444  34
         SparqlParser.quadsNotTriples_return retval = new SparqlParser.quadsNotTriples_return();
 8445  34
         retval.start = input.LT(1);
 8446  
 
 8447  
 
 8448  34
         Object root_0 = null;
 8449  
 
 8450  34
         Token GRAPH186=null;
 8451  34
         Token OPEN_CURLY_BRACE188=null;
 8452  34
         Token CLOSE_CURLY_BRACE190=null;
 8453  34
         SparqlParser.varOrIRIref_return varOrIRIref187 =null;
 8454  
 
 8455  34
         SparqlParser.triplesTemplate_return triplesTemplate189 =null;
 8456  
 
 8457  
 
 8458  34
         Object GRAPH186_tree=null;
 8459  34
         Object OPEN_CURLY_BRACE188_tree=null;
 8460  34
         Object CLOSE_CURLY_BRACE190_tree=null;
 8461  34
         RewriteRuleTokenStream stream_GRAPH=new RewriteRuleTokenStream(adaptor,"token GRAPH");
 8462  34
         RewriteRuleTokenStream stream_OPEN_CURLY_BRACE=new RewriteRuleTokenStream(adaptor,"token OPEN_CURLY_BRACE");
 8463  34
         RewriteRuleTokenStream stream_CLOSE_CURLY_BRACE=new RewriteRuleTokenStream(adaptor,"token CLOSE_CURLY_BRACE");
 8464  34
         RewriteRuleSubtreeStream stream_varOrIRIref=new RewriteRuleSubtreeStream(adaptor,"rule varOrIRIref");
 8465  34
         RewriteRuleSubtreeStream stream_triplesTemplate=new RewriteRuleSubtreeStream(adaptor,"rule triplesTemplate");
 8466  
         try {
 8467  
             // com\\googlecode\\sparkleg\\Sparql.g:279:5: ( GRAPH varOrIRIref OPEN_CURLY_BRACE ( triplesTemplate )? CLOSE_CURLY_BRACE -> ^( GRAPH varOrIRIref ( triplesTemplate )? ) )
 8468  
             // com\\googlecode\\sparkleg\\Sparql.g:279:7: GRAPH varOrIRIref OPEN_CURLY_BRACE ( triplesTemplate )? CLOSE_CURLY_BRACE
 8469  
             {
 8470  34
             GRAPH186=(Token)match(input,GRAPH,FOLLOW_GRAPH_in_quadsNotTriples2229);  
 8471  34
             stream_GRAPH.add(GRAPH186);
 8472  
 
 8473  
 
 8474  34
             pushFollow(FOLLOW_varOrIRIref_in_quadsNotTriples2231);
 8475  34
             varOrIRIref187=varOrIRIref();
 8476  
 
 8477  34
             state._fsp--;
 8478  
 
 8479  34
             stream_varOrIRIref.add(varOrIRIref187.getTree());
 8480  
 
 8481  34
             OPEN_CURLY_BRACE188=(Token)match(input,OPEN_CURLY_BRACE,FOLLOW_OPEN_CURLY_BRACE_in_quadsNotTriples2233);  
 8482  34
             stream_OPEN_CURLY_BRACE.add(OPEN_CURLY_BRACE188);
 8483  
 
 8484  
 
 8485  
             // com\\googlecode\\sparkleg\\Sparql.g:279:42: ( triplesTemplate )?
 8486  34
             int alt62=2;
 8487  34
             switch ( input.LA(1) ) {
 8488  
                 case BLANK_NODE_LABEL:
 8489  
                 case DECIMAL:
 8490  
                 case DECIMAL_NEGATIVE:
 8491  
                 case DECIMAL_POSITIVE:
 8492  
                 case DOUBLE:
 8493  
                 case DOUBLE_NEGATIVE:
 8494  
                 case DOUBLE_POSITIVE:
 8495  
                 case FALSE:
 8496  
                 case INTEGER:
 8497  
                 case INTEGER_NEGATIVE:
 8498  
                 case INTEGER_POSITIVE:
 8499  
                 case IRI_REF:
 8500  
                 case OPEN_BRACE:
 8501  
                 case OPEN_SQUARE_BRACKET:
 8502  
                 case PNAME_LN:
 8503  
                 case PNAME_NS:
 8504  
                 case STRING_LITERAL1:
 8505  
                 case STRING_LITERAL2:
 8506  
                 case STRING_LITERAL_LONG1:
 8507  
                 case STRING_LITERAL_LONG2:
 8508  
                 case TRUE:
 8509  
                 case VAR1:
 8510  
                 case VAR2:
 8511  
                     {
 8512  34
                     alt62=1;
 8513  
                     }
 8514  
                     break;
 8515  
             }
 8516  
 
 8517  34
             switch (alt62) {
 8518  
                 case 1 :
 8519  
                     // com\\googlecode\\sparkleg\\Sparql.g:279:42: triplesTemplate
 8520  
                     {
 8521  34
                     pushFollow(FOLLOW_triplesTemplate_in_quadsNotTriples2235);
 8522  34
                     triplesTemplate189=triplesTemplate();
 8523  
 
 8524  34
                     state._fsp--;
 8525  
 
 8526  34
                     stream_triplesTemplate.add(triplesTemplate189.getTree());
 8527  
 
 8528  
                     }
 8529  
                     break;
 8530  
 
 8531  
             }
 8532  
 
 8533  
 
 8534  34
             CLOSE_CURLY_BRACE190=(Token)match(input,CLOSE_CURLY_BRACE,FOLLOW_CLOSE_CURLY_BRACE_in_quadsNotTriples2238);  
 8535  34
             stream_CLOSE_CURLY_BRACE.add(CLOSE_CURLY_BRACE190);
 8536  
 
 8537  
 
 8538  
             // AST REWRITE
 8539  
             // elements: varOrIRIref, triplesTemplate, GRAPH
 8540  
             // token labels: 
 8541  
             // rule labels: retval
 8542  
             // token list labels: 
 8543  
             // rule list labels: 
 8544  
             // wildcard labels: 
 8545  34
             retval.tree = root_0;
 8546  34
             RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 8547  
 
 8548  34
             root_0 = (Object)adaptor.nil();
 8549  
             // 279:77: -> ^( GRAPH varOrIRIref ( triplesTemplate )? )
 8550  
             {
 8551  
                 // com\\googlecode\\sparkleg\\Sparql.g:279:80: ^( GRAPH varOrIRIref ( triplesTemplate )? )
 8552  
                 {
 8553  34
                 Object root_1 = (Object)adaptor.nil();
 8554  34
                 root_1 = (Object)adaptor.becomeRoot(
 8555  
                 stream_GRAPH.nextNode()
 8556  
                 , root_1);
 8557  
 
 8558  34
                 adaptor.addChild(root_1, stream_varOrIRIref.nextTree());
 8559  
 
 8560  
                 // com\\googlecode\\sparkleg\\Sparql.g:279:100: ( triplesTemplate )?
 8561  34
                 if ( stream_triplesTemplate.hasNext() ) {
 8562  34
                     adaptor.addChild(root_1, stream_triplesTemplate.nextTree());
 8563  
 
 8564  
                 }
 8565  34
                 stream_triplesTemplate.reset();
 8566  
 
 8567  34
                 adaptor.addChild(root_0, root_1);
 8568  
                 }
 8569  
 
 8570  
             }
 8571  
 
 8572  
 
 8573  34
             retval.tree = root_0;
 8574  
 
 8575  
             }
 8576  
 
 8577  34
             retval.stop = input.LT(-1);
 8578  
 
 8579  
 
 8580  34
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 8581  34
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 8582  
 
 8583  
         }
 8584  0
         catch (RecognitionException re) {
 8585  0
             reportError(re);
 8586  0
             recover(input,re);
 8587  0
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 8588  
 
 8589  
         }
 8590  
 
 8591  0
         finally {
 8592  
                 // do for sure before leaving
 8593  34
         }
 8594  34
         return retval;
 8595  
     }
 8596  
     // $ANTLR end "quadsNotTriples"
 8597  
 
 8598  
 
 8599  122
     public static class triplesTemplate_return extends ParserRuleReturnScope {
 8600  
         Object tree;
 8601  122
         public Object getTree() { return tree; }
 8602  
     };
 8603  
 
 8604  
 
 8605  
     // $ANTLR start "triplesTemplate"
 8606  
     // com\\googlecode\\sparkleg\\Sparql.g:282:1: triplesTemplate : triplesSameSubject ( DOT triplesSameSubject )* ( DOT )? -> ^( TRIPLES_TEMPLATE ( triplesSameSubject )* ) ;
 8607  
     public final SparqlParser.triplesTemplate_return triplesTemplate() throws RecognitionException {
 8608  122
         SparqlParser.triplesTemplate_return retval = new SparqlParser.triplesTemplate_return();
 8609  122
         retval.start = input.LT(1);
 8610  
 
 8611  
 
 8612  122
         Object root_0 = null;
 8613  
 
 8614  122
         Token DOT192=null;
 8615  122
         Token DOT194=null;
 8616  122
         SparqlParser.triplesSameSubject_return triplesSameSubject191 =null;
 8617  
 
 8618  122
         SparqlParser.triplesSameSubject_return triplesSameSubject193 =null;
 8619  
 
 8620  
 
 8621  122
         Object DOT192_tree=null;
 8622  122
         Object DOT194_tree=null;
 8623  122
         RewriteRuleTokenStream stream_DOT=new RewriteRuleTokenStream(adaptor,"token DOT");
 8624  122
         RewriteRuleSubtreeStream stream_triplesSameSubject=new RewriteRuleSubtreeStream(adaptor,"rule triplesSameSubject");
 8625  
         try {
 8626  
             // com\\googlecode\\sparkleg\\Sparql.g:283:5: ( triplesSameSubject ( DOT triplesSameSubject )* ( DOT )? -> ^( TRIPLES_TEMPLATE ( triplesSameSubject )* ) )
 8627  
             // com\\googlecode\\sparkleg\\Sparql.g:283:7: triplesSameSubject ( DOT triplesSameSubject )* ( DOT )?
 8628  
             {
 8629  122
             pushFollow(FOLLOW_triplesSameSubject_in_triplesTemplate2270);
 8630  122
             triplesSameSubject191=triplesSameSubject();
 8631  
 
 8632  122
             state._fsp--;
 8633  
 
 8634  122
             stream_triplesSameSubject.add(triplesSameSubject191.getTree());
 8635  
 
 8636  
             // com\\googlecode\\sparkleg\\Sparql.g:283:26: ( DOT triplesSameSubject )*
 8637  
             loop63:
 8638  
             do {
 8639  126
                 int alt63=2;
 8640  126
                 switch ( input.LA(1) ) {
 8641  
                 case DOT:
 8642  
                     {
 8643  104
                     switch ( input.LA(2) ) {
 8644  
                     case BLANK_NODE_LABEL:
 8645  
                     case DECIMAL:
 8646  
                     case DECIMAL_NEGATIVE:
 8647  
                     case DECIMAL_POSITIVE:
 8648  
                     case DOUBLE:
 8649  
                     case DOUBLE_NEGATIVE:
 8650  
                     case DOUBLE_POSITIVE:
 8651  
                     case FALSE:
 8652  
                     case INTEGER:
 8653  
                     case INTEGER_NEGATIVE:
 8654  
                     case INTEGER_POSITIVE:
 8655  
                     case IRI_REF:
 8656  
                     case OPEN_BRACE:
 8657  
                     case OPEN_SQUARE_BRACKET:
 8658  
                     case PNAME_LN:
 8659  
                     case PNAME_NS:
 8660  
                     case STRING_LITERAL1:
 8661  
                     case STRING_LITERAL2:
 8662  
                     case STRING_LITERAL_LONG1:
 8663  
                     case STRING_LITERAL_LONG2:
 8664  
                     case TRUE:
 8665  
                     case VAR1:
 8666  
                     case VAR2:
 8667  
                         {
 8668  4
                         alt63=1;
 8669  
                         }
 8670  
                         break;
 8671  
 
 8672  
                     }
 8673  
 
 8674  
                     }
 8675  
                     break;
 8676  
 
 8677  
                 }
 8678  
 
 8679  126
                 switch (alt63) {
 8680  
                     case 1 :
 8681  
                         // com\\googlecode\\sparkleg\\Sparql.g:283:27: DOT triplesSameSubject
 8682  
                         {
 8683  4
                         DOT192=(Token)match(input,DOT,FOLLOW_DOT_in_triplesTemplate2273);  
 8684  4
                         stream_DOT.add(DOT192);
 8685  
 
 8686  
 
 8687  4
                         pushFollow(FOLLOW_triplesSameSubject_in_triplesTemplate2275);
 8688  4
                         triplesSameSubject193=triplesSameSubject();
 8689  
 
 8690  4
                         state._fsp--;
 8691  
 
 8692  4
                         stream_triplesSameSubject.add(triplesSameSubject193.getTree());
 8693  
 
 8694  
                         }
 8695  4
                         break;
 8696  
 
 8697  
                     default :
 8698  122
                         break loop63;
 8699  
                 }
 8700  4
             } while (true);
 8701  
 
 8702  
 
 8703  
             // com\\googlecode\\sparkleg\\Sparql.g:283:52: ( DOT )?
 8704  122
             int alt64=2;
 8705  122
             switch ( input.LA(1) ) {
 8706  
                 case DOT:
 8707  
                     {
 8708  100
                     alt64=1;
 8709  
                     }
 8710  
                     break;
 8711  
             }
 8712  
 
 8713  122
             switch (alt64) {
 8714  
                 case 1 :
 8715  
                     // com\\googlecode\\sparkleg\\Sparql.g:283:52: DOT
 8716  
                     {
 8717  100
                     DOT194=(Token)match(input,DOT,FOLLOW_DOT_in_triplesTemplate2279);  
 8718  100
                     stream_DOT.add(DOT194);
 8719  
 
 8720  
 
 8721  
                     }
 8722  
                     break;
 8723  
 
 8724  
             }
 8725  
 
 8726  
 
 8727  
             // AST REWRITE
 8728  
             // elements: triplesSameSubject
 8729  
             // token labels: 
 8730  
             // rule labels: retval
 8731  
             // token list labels: 
 8732  
             // rule list labels: 
 8733  
             // wildcard labels: 
 8734  122
             retval.tree = root_0;
 8735  122
             RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 8736  
 
 8737  122
             root_0 = (Object)adaptor.nil();
 8738  
             // 283:57: -> ^( TRIPLES_TEMPLATE ( triplesSameSubject )* )
 8739  
             {
 8740  
                 // com\\googlecode\\sparkleg\\Sparql.g:283:60: ^( TRIPLES_TEMPLATE ( triplesSameSubject )* )
 8741  
                 {
 8742  122
                 Object root_1 = (Object)adaptor.nil();
 8743  122
                 root_1 = (Object)adaptor.becomeRoot(
 8744  
                 (Object)adaptor.create(TRIPLES_TEMPLATE, "TRIPLES_TEMPLATE")
 8745  
                 , root_1);
 8746  
 
 8747  
                 // com\\googlecode\\sparkleg\\Sparql.g:283:79: ( triplesSameSubject )*
 8748  248
                 while ( stream_triplesSameSubject.hasNext() ) {
 8749  126
                     adaptor.addChild(root_1, stream_triplesSameSubject.nextTree());
 8750  
 
 8751  
                 }
 8752  122
                 stream_triplesSameSubject.reset();
 8753  
 
 8754  122
                 adaptor.addChild(root_0, root_1);
 8755  
                 }
 8756  
 
 8757  
             }
 8758  
 
 8759  
 
 8760  122
             retval.tree = root_0;
 8761  
 
 8762  
             }
 8763  
 
 8764  122
             retval.stop = input.LT(-1);
 8765  
 
 8766  
 
 8767  122
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 8768  122
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 8769  
 
 8770  
         }
 8771  0
         catch (RecognitionException re) {
 8772  0
             reportError(re);
 8773  0
             recover(input,re);
 8774  0
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 8775  
 
 8776  
         }
 8777  
 
 8778  0
         finally {
 8779  
                 // do for sure before leaving
 8780  122
         }
 8781  122
         return retval;
 8782  
     }
 8783  
     // $ANTLR end "triplesTemplate"
 8784  
 
 8785  
 
 8786  2640
     public static class groupGraphPattern_return extends ParserRuleReturnScope {
 8787  
         Object tree;
 8788  2640
         public Object getTree() { return tree; }
 8789  
     };
 8790  
 
 8791  
 
 8792  
     // $ANTLR start "groupGraphPattern"
 8793  
     // com\\googlecode\\sparkleg\\Sparql.g:286:1: groupGraphPattern : ( OPEN_CURLY_BRACE subSelect CLOSE_CURLY_BRACE -> ^( GROUP_GRAPH_PATTERN subSelect ) | OPEN_CURLY_BRACE groupGraphPatternSub CLOSE_CURLY_BRACE -> ^( GROUP_GRAPH_PATTERN groupGraphPatternSub ) | OPEN_CURLY_BRACE CLOSE_CURLY_BRACE -> ^( GROUP_GRAPH_PATTERN GROUP_GRAPH_PATTERN ) );
 8794  
     public final SparqlParser.groupGraphPattern_return groupGraphPattern() throws RecognitionException {
 8795  2640
         SparqlParser.groupGraphPattern_return retval = new SparqlParser.groupGraphPattern_return();
 8796  2640
         retval.start = input.LT(1);
 8797  
 
 8798  
 
 8799  2640
         Object root_0 = null;
 8800  
 
 8801  2640
         Token OPEN_CURLY_BRACE195=null;
 8802  2640
         Token CLOSE_CURLY_BRACE197=null;
 8803  2640
         Token OPEN_CURLY_BRACE198=null;
 8804  2640
         Token CLOSE_CURLY_BRACE200=null;
 8805  2640
         Token OPEN_CURLY_BRACE201=null;
 8806  2640
         Token CLOSE_CURLY_BRACE202=null;
 8807  2640
         SparqlParser.subSelect_return subSelect196 =null;
 8808  
 
 8809  2640
         SparqlParser.groupGraphPatternSub_return groupGraphPatternSub199 =null;
 8810  
 
 8811  
 
 8812  2640
         Object OPEN_CURLY_BRACE195_tree=null;
 8813  2640
         Object CLOSE_CURLY_BRACE197_tree=null;
 8814  2640
         Object OPEN_CURLY_BRACE198_tree=null;
 8815  2640
         Object CLOSE_CURLY_BRACE200_tree=null;
 8816  2640
         Object OPEN_CURLY_BRACE201_tree=null;
 8817  2640
         Object CLOSE_CURLY_BRACE202_tree=null;
 8818  2640
         RewriteRuleTokenStream stream_OPEN_CURLY_BRACE=new RewriteRuleTokenStream(adaptor,"token OPEN_CURLY_BRACE");
 8819  2640
         RewriteRuleTokenStream stream_CLOSE_CURLY_BRACE=new RewriteRuleTokenStream(adaptor,"token CLOSE_CURLY_BRACE");
 8820  2640
         RewriteRuleSubtreeStream stream_groupGraphPatternSub=new RewriteRuleSubtreeStream(adaptor,"rule groupGraphPatternSub");
 8821  2640
         RewriteRuleSubtreeStream stream_subSelect=new RewriteRuleSubtreeStream(adaptor,"rule subSelect");
 8822  
         try {
 8823  
             // com\\googlecode\\sparkleg\\Sparql.g:287:5: ( OPEN_CURLY_BRACE subSelect CLOSE_CURLY_BRACE -> ^( GROUP_GRAPH_PATTERN subSelect ) | OPEN_CURLY_BRACE groupGraphPatternSub CLOSE_CURLY_BRACE -> ^( GROUP_GRAPH_PATTERN groupGraphPatternSub ) | OPEN_CURLY_BRACE CLOSE_CURLY_BRACE -> ^( GROUP_GRAPH_PATTERN GROUP_GRAPH_PATTERN ) )
 8824  2640
             int alt65=3;
 8825  2640
             switch ( input.LA(1) ) {
 8826  
             case OPEN_CURLY_BRACE:
 8827  
                 {
 8828  2640
                 switch ( input.LA(2) ) {
 8829  
                 case CLOSE_CURLY_BRACE:
 8830  
                     {
 8831  44
                     alt65=3;
 8832  
                     }
 8833  44
                     break;
 8834  
                 case SELECT:
 8835  
                     {
 8836  46
                     alt65=1;
 8837  
                     }
 8838  46
                     break;
 8839  
                 case BIND:
 8840  
                 case BLANK_NODE_LABEL:
 8841  
                 case DECIMAL:
 8842  
                 case DECIMAL_NEGATIVE:
 8843  
                 case DECIMAL_POSITIVE:
 8844  
                 case DOUBLE:
 8845  
                 case DOUBLE_NEGATIVE:
 8846  
                 case DOUBLE_POSITIVE:
 8847  
                 case FALSE:
 8848  
                 case FILTER:
 8849  
                 case GRAPH:
 8850  
                 case INTEGER:
 8851  
                 case INTEGER_NEGATIVE:
 8852  
                 case INTEGER_POSITIVE:
 8853  
                 case IRI_REF:
 8854  
                 case MINUS_KEYWORD:
 8855  
                 case OPEN_BRACE:
 8856  
                 case OPEN_CURLY_BRACE:
 8857  
                 case OPEN_SQUARE_BRACKET:
 8858  
                 case OPTIONAL:
 8859  
                 case PNAME_LN:
 8860  
                 case PNAME_NS:
 8861  
                 case SERVICE:
 8862  
                 case STRING_LITERAL1:
 8863  
                 case STRING_LITERAL2:
 8864  
                 case STRING_LITERAL_LONG1:
 8865  
                 case STRING_LITERAL_LONG2:
 8866  
                 case TRUE:
 8867  
                 case VAR1:
 8868  
                 case VAR2:
 8869  
                     {
 8870  2550
                     alt65=2;
 8871  
                     }
 8872  2550
                     break;
 8873  
                 default:
 8874  0
                     NoViableAltException nvae =
 8875  
                         new NoViableAltException("", 65, 1, input);
 8876  
 
 8877  0
                     throw nvae;
 8878  
 
 8879  
                 }
 8880  
 
 8881  
                 }
 8882  2640
                 break;
 8883  
             default:
 8884  0
                 NoViableAltException nvae =
 8885  
                     new NoViableAltException("", 65, 0, input);
 8886  
 
 8887  0
                 throw nvae;
 8888  
 
 8889  
             }
 8890  
 
 8891  2640
             switch (alt65) {
 8892  
                 case 1 :
 8893  
                     // com\\googlecode\\sparkleg\\Sparql.g:287:7: OPEN_CURLY_BRACE subSelect CLOSE_CURLY_BRACE
 8894  
                     {
 8895  46
                     OPEN_CURLY_BRACE195=(Token)match(input,OPEN_CURLY_BRACE,FOLLOW_OPEN_CURLY_BRACE_in_groupGraphPattern2311);  
 8896  46
                     stream_OPEN_CURLY_BRACE.add(OPEN_CURLY_BRACE195);
 8897  
 
 8898  
 
 8899  46
                     pushFollow(FOLLOW_subSelect_in_groupGraphPattern2313);
 8900  46
                     subSelect196=subSelect();
 8901  
 
 8902  46
                     state._fsp--;
 8903  
 
 8904  46
                     stream_subSelect.add(subSelect196.getTree());
 8905  
 
 8906  46
                     CLOSE_CURLY_BRACE197=(Token)match(input,CLOSE_CURLY_BRACE,FOLLOW_CLOSE_CURLY_BRACE_in_groupGraphPattern2315);  
 8907  46
                     stream_CLOSE_CURLY_BRACE.add(CLOSE_CURLY_BRACE197);
 8908  
 
 8909  
 
 8910  
                     // AST REWRITE
 8911  
                     // elements: subSelect
 8912  
                     // token labels: 
 8913  
                     // rule labels: retval
 8914  
                     // token list labels: 
 8915  
                     // rule list labels: 
 8916  
                     // wildcard labels: 
 8917  46
                     retval.tree = root_0;
 8918  46
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 8919  
 
 8920  46
                     root_0 = (Object)adaptor.nil();
 8921  
                     // 287:52: -> ^( GROUP_GRAPH_PATTERN subSelect )
 8922  
                     {
 8923  
                         // com\\googlecode\\sparkleg\\Sparql.g:287:55: ^( GROUP_GRAPH_PATTERN subSelect )
 8924  
                         {
 8925  46
                         Object root_1 = (Object)adaptor.nil();
 8926  46
                         root_1 = (Object)adaptor.becomeRoot(
 8927  
                         (Object)adaptor.create(GROUP_GRAPH_PATTERN, "GROUP_GRAPH_PATTERN")
 8928  
                         , root_1);
 8929  
 
 8930  46
                         adaptor.addChild(root_1, stream_subSelect.nextTree());
 8931  
 
 8932  46
                         adaptor.addChild(root_0, root_1);
 8933  
                         }
 8934  
 
 8935  
                     }
 8936  
 
 8937  
 
 8938  46
                     retval.tree = root_0;
 8939  
 
 8940  
                     }
 8941  46
                     break;
 8942  
                 case 2 :
 8943  
                     // com\\googlecode\\sparkleg\\Sparql.g:288:7: OPEN_CURLY_BRACE groupGraphPatternSub CLOSE_CURLY_BRACE
 8944  
                     {
 8945  2550
                     OPEN_CURLY_BRACE198=(Token)match(input,OPEN_CURLY_BRACE,FOLLOW_OPEN_CURLY_BRACE_in_groupGraphPattern2331);  
 8946  2550
                     stream_OPEN_CURLY_BRACE.add(OPEN_CURLY_BRACE198);
 8947  
 
 8948  
 
 8949  2550
                     pushFollow(FOLLOW_groupGraphPatternSub_in_groupGraphPattern2333);
 8950  2550
                     groupGraphPatternSub199=groupGraphPatternSub();
 8951  
 
 8952  2550
                     state._fsp--;
 8953  
 
 8954  2550
                     stream_groupGraphPatternSub.add(groupGraphPatternSub199.getTree());
 8955  
 
 8956  2550
                     CLOSE_CURLY_BRACE200=(Token)match(input,CLOSE_CURLY_BRACE,FOLLOW_CLOSE_CURLY_BRACE_in_groupGraphPattern2335);  
 8957  2550
                     stream_CLOSE_CURLY_BRACE.add(CLOSE_CURLY_BRACE200);
 8958  
 
 8959  
 
 8960  
                     // AST REWRITE
 8961  
                     // elements: groupGraphPatternSub
 8962  
                     // token labels: 
 8963  
                     // rule labels: retval
 8964  
                     // token list labels: 
 8965  
                     // rule list labels: 
 8966  
                     // wildcard labels: 
 8967  2550
                     retval.tree = root_0;
 8968  2550
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 8969  
 
 8970  2550
                     root_0 = (Object)adaptor.nil();
 8971  
                     // 288:63: -> ^( GROUP_GRAPH_PATTERN groupGraphPatternSub )
 8972  
                     {
 8973  
                         // com\\googlecode\\sparkleg\\Sparql.g:288:66: ^( GROUP_GRAPH_PATTERN groupGraphPatternSub )
 8974  
                         {
 8975  2550
                         Object root_1 = (Object)adaptor.nil();
 8976  2550
                         root_1 = (Object)adaptor.becomeRoot(
 8977  
                         (Object)adaptor.create(GROUP_GRAPH_PATTERN, "GROUP_GRAPH_PATTERN")
 8978  
                         , root_1);
 8979  
 
 8980  2550
                         adaptor.addChild(root_1, stream_groupGraphPatternSub.nextTree());
 8981  
 
 8982  2550
                         adaptor.addChild(root_0, root_1);
 8983  
                         }
 8984  
 
 8985  
                     }
 8986  
 
 8987  
 
 8988  2550
                     retval.tree = root_0;
 8989  
 
 8990  
                     }
 8991  2550
                     break;
 8992  
                 case 3 :
 8993  
                     // com\\googlecode\\sparkleg\\Sparql.g:289:7: OPEN_CURLY_BRACE CLOSE_CURLY_BRACE
 8994  
                     {
 8995  44
                     OPEN_CURLY_BRACE201=(Token)match(input,OPEN_CURLY_BRACE,FOLLOW_OPEN_CURLY_BRACE_in_groupGraphPattern2351);  
 8996  44
                     stream_OPEN_CURLY_BRACE.add(OPEN_CURLY_BRACE201);
 8997  
 
 8998  
 
 8999  44
                     CLOSE_CURLY_BRACE202=(Token)match(input,CLOSE_CURLY_BRACE,FOLLOW_CLOSE_CURLY_BRACE_in_groupGraphPattern2353);  
 9000  44
                     stream_CLOSE_CURLY_BRACE.add(CLOSE_CURLY_BRACE202);
 9001  
 
 9002  
 
 9003  
                     // AST REWRITE
 9004  
                     // elements: 
 9005  
                     // token labels: 
 9006  
                     // rule labels: retval
 9007  
                     // token list labels: 
 9008  
                     // rule list labels: 
 9009  
                     // wildcard labels: 
 9010  44
                     retval.tree = root_0;
 9011  44
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 9012  
 
 9013  44
                     root_0 = (Object)adaptor.nil();
 9014  
                     // 289:42: -> ^( GROUP_GRAPH_PATTERN GROUP_GRAPH_PATTERN )
 9015  
                     {
 9016  
                         // com\\googlecode\\sparkleg\\Sparql.g:289:45: ^( GROUP_GRAPH_PATTERN GROUP_GRAPH_PATTERN )
 9017  
                         {
 9018  44
                         Object root_1 = (Object)adaptor.nil();
 9019  44
                         root_1 = (Object)adaptor.becomeRoot(
 9020  
                         (Object)adaptor.create(GROUP_GRAPH_PATTERN, "GROUP_GRAPH_PATTERN")
 9021  
                         , root_1);
 9022  
 
 9023  44
                         adaptor.addChild(root_1, 
 9024  
                         (Object)adaptor.create(GROUP_GRAPH_PATTERN, "GROUP_GRAPH_PATTERN")
 9025  
                         );
 9026  
 
 9027  44
                         adaptor.addChild(root_0, root_1);
 9028  
                         }
 9029  
 
 9030  
                     }
 9031  
 
 9032  
 
 9033  44
                     retval.tree = root_0;
 9034  
 
 9035  
                     }
 9036  
                     break;
 9037  
 
 9038  
             }
 9039  2640
             retval.stop = input.LT(-1);
 9040  
 
 9041  
 
 9042  2640
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 9043  2640
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 9044  
 
 9045  
         }
 9046  0
         catch (RecognitionException re) {
 9047  0
             reportError(re);
 9048  0
             recover(input,re);
 9049  0
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 9050  
 
 9051  
         }
 9052  
 
 9053  0
         finally {
 9054  
                 // do for sure before leaving
 9055  2640
         }
 9056  2640
         return retval;
 9057  
     }
 9058  
     // $ANTLR end "groupGraphPattern"
 9059  
 
 9060  
 
 9061  2550
     public static class groupGraphPatternSub_return extends ParserRuleReturnScope {
 9062  
         Object tree;
 9063  2550
         public Object getTree() { return tree; }
 9064  
     };
 9065  
 
 9066  
 
 9067  
     // $ANTLR start "groupGraphPatternSub"
 9068  
     // com\\googlecode\\sparkleg\\Sparql.g:292:1: groupGraphPatternSub : ( triplesBlock ( groupGraphPatternSubDetail )* -> triplesBlock ( groupGraphPatternSubDetail )* | ( groupGraphPatternSubDetail )+ -> ( groupGraphPatternSubDetail )+ );
 9069  
     public final SparqlParser.groupGraphPatternSub_return groupGraphPatternSub() throws RecognitionException {
 9070  2550
         SparqlParser.groupGraphPatternSub_return retval = new SparqlParser.groupGraphPatternSub_return();
 9071  2550
         retval.start = input.LT(1);
 9072  
 
 9073  
 
 9074  2550
         Object root_0 = null;
 9075  
 
 9076  2550
         SparqlParser.triplesBlock_return triplesBlock203 =null;
 9077  
 
 9078  2550
         SparqlParser.groupGraphPatternSubDetail_return groupGraphPatternSubDetail204 =null;
 9079  
 
 9080  2550
         SparqlParser.groupGraphPatternSubDetail_return groupGraphPatternSubDetail205 =null;
 9081  
 
 9082  
 
 9083  2550
         RewriteRuleSubtreeStream stream_triplesBlock=new RewriteRuleSubtreeStream(adaptor,"rule triplesBlock");
 9084  2550
         RewriteRuleSubtreeStream stream_groupGraphPatternSubDetail=new RewriteRuleSubtreeStream(adaptor,"rule groupGraphPatternSubDetail");
 9085  
         try {
 9086  
             // com\\googlecode\\sparkleg\\Sparql.g:293:5: ( triplesBlock ( groupGraphPatternSubDetail )* -> triplesBlock ( groupGraphPatternSubDetail )* | ( groupGraphPatternSubDetail )+ -> ( groupGraphPatternSubDetail )+ )
 9087  2550
             int alt68=2;
 9088  2550
             switch ( input.LA(1) ) {
 9089  
             case BLANK_NODE_LABEL:
 9090  
             case DECIMAL:
 9091  
             case DECIMAL_NEGATIVE:
 9092  
             case DECIMAL_POSITIVE:
 9093  
             case DOUBLE:
 9094  
             case DOUBLE_NEGATIVE:
 9095  
             case DOUBLE_POSITIVE:
 9096  
             case FALSE:
 9097  
             case INTEGER:
 9098  
             case INTEGER_NEGATIVE:
 9099  
             case INTEGER_POSITIVE:
 9100  
             case IRI_REF:
 9101  
             case OPEN_BRACE:
 9102  
             case OPEN_SQUARE_BRACKET:
 9103  
             case PNAME_LN:
 9104  
             case PNAME_NS:
 9105  
             case STRING_LITERAL1:
 9106  
             case STRING_LITERAL2:
 9107  
             case STRING_LITERAL_LONG1:
 9108  
             case STRING_LITERAL_LONG2:
 9109  
             case TRUE:
 9110  
             case VAR1:
 9111  
             case VAR2:
 9112  
                 {
 9113  2270
                 alt68=1;
 9114  
                 }
 9115  2270
                 break;
 9116  
             case BIND:
 9117  
             case FILTER:
 9118  
             case GRAPH:
 9119  
             case MINUS_KEYWORD:
 9120  
             case OPEN_CURLY_BRACE:
 9121  
             case OPTIONAL:
 9122  
             case SERVICE:
 9123  
                 {
 9124  280
                 alt68=2;
 9125  
                 }
 9126  280
                 break;
 9127  
             default:
 9128  0
                 NoViableAltException nvae =
 9129  
                     new NoViableAltException("", 68, 0, input);
 9130  
 
 9131  0
                 throw nvae;
 9132  
 
 9133  
             }
 9134  
 
 9135  2550
             switch (alt68) {
 9136  
                 case 1 :
 9137  
                     // com\\googlecode\\sparkleg\\Sparql.g:293:7: triplesBlock ( groupGraphPatternSubDetail )*
 9138  
                     {
 9139  2270
                     pushFollow(FOLLOW_triplesBlock_in_groupGraphPatternSub2382);
 9140  2270
                     triplesBlock203=triplesBlock();
 9141  
 
 9142  2270
                     state._fsp--;
 9143  
 
 9144  2270
                     stream_triplesBlock.add(triplesBlock203.getTree());
 9145  
 
 9146  
                     // com\\googlecode\\sparkleg\\Sparql.g:293:20: ( groupGraphPatternSubDetail )*
 9147  
                     loop66:
 9148  
                     do {
 9149  3144
                         int alt66=2;
 9150  3144
                         switch ( input.LA(1) ) {
 9151  
                         case BIND:
 9152  
                         case FILTER:
 9153  
                         case GRAPH:
 9154  
                         case MINUS_KEYWORD:
 9155  
                         case OPEN_CURLY_BRACE:
 9156  
                         case OPTIONAL:
 9157  
                         case SERVICE:
 9158  
                             {
 9159  874
                             alt66=1;
 9160  
                             }
 9161  
                             break;
 9162  
 
 9163  
                         }
 9164  
 
 9165  3144
                         switch (alt66) {
 9166  
                             case 1 :
 9167  
                                 // com\\googlecode\\sparkleg\\Sparql.g:293:20: groupGraphPatternSubDetail
 9168  
                                 {
 9169  874
                                 pushFollow(FOLLOW_groupGraphPatternSubDetail_in_groupGraphPatternSub2384);
 9170  874
                                 groupGraphPatternSubDetail204=groupGraphPatternSubDetail();
 9171  
 
 9172  874
                                 state._fsp--;
 9173  
 
 9174  874
                                 stream_groupGraphPatternSubDetail.add(groupGraphPatternSubDetail204.getTree());
 9175  
 
 9176  
                                 }
 9177  874
                                 break;
 9178  
 
 9179  
                             default :
 9180  2270
                                 break loop66;
 9181  
                         }
 9182  874
                     } while (true);
 9183  
 
 9184  
 
 9185  
                     // AST REWRITE
 9186  
                     // elements: groupGraphPatternSubDetail, triplesBlock
 9187  
                     // token labels: 
 9188  
                     // rule labels: retval
 9189  
                     // token list labels: 
 9190  
                     // rule list labels: 
 9191  
                     // wildcard labels: 
 9192  2270
                     retval.tree = root_0;
 9193  2270
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 9194  
 
 9195  2270
                     root_0 = (Object)adaptor.nil();
 9196  
                     // 293:48: -> triplesBlock ( groupGraphPatternSubDetail )*
 9197  
                     {
 9198  2270
                         adaptor.addChild(root_0, stream_triplesBlock.nextTree());
 9199  
 
 9200  
                         // com\\googlecode\\sparkleg\\Sparql.g:293:64: ( groupGraphPatternSubDetail )*
 9201  3144
                         while ( stream_groupGraphPatternSubDetail.hasNext() ) {
 9202  874
                             adaptor.addChild(root_0, stream_groupGraphPatternSubDetail.nextTree());
 9203  
 
 9204  
                         }
 9205  2270
                         stream_groupGraphPatternSubDetail.reset();
 9206  
 
 9207  
                     }
 9208  
 
 9209  
 
 9210  2270
                     retval.tree = root_0;
 9211  
 
 9212  
                     }
 9213  2270
                     break;
 9214  
                 case 2 :
 9215  
                     // com\\googlecode\\sparkleg\\Sparql.g:294:7: ( groupGraphPatternSubDetail )+
 9216  
                     {
 9217  
                     // com\\googlecode\\sparkleg\\Sparql.g:294:7: ( groupGraphPatternSubDetail )+
 9218  280
                     int cnt67=0;
 9219  
                     loop67:
 9220  
                     do {
 9221  624
                         int alt67=2;
 9222  624
                         switch ( input.LA(1) ) {
 9223  
                         case BIND:
 9224  
                         case FILTER:
 9225  
                         case GRAPH:
 9226  
                         case MINUS_KEYWORD:
 9227  
                         case OPEN_CURLY_BRACE:
 9228  
                         case OPTIONAL:
 9229  
                         case SERVICE:
 9230  
                             {
 9231  344
                             alt67=1;
 9232  
                             }
 9233  
                             break;
 9234  
 
 9235  
                         }
 9236  
 
 9237  624
                         switch (alt67) {
 9238  
                             case 1 :
 9239  
                                 // com\\googlecode\\sparkleg\\Sparql.g:294:7: groupGraphPatternSubDetail
 9240  
                                 {
 9241  344
                                 pushFollow(FOLLOW_groupGraphPatternSubDetail_in_groupGraphPatternSub2400);
 9242  344
                                 groupGraphPatternSubDetail205=groupGraphPatternSubDetail();
 9243  
 
 9244  344
                                 state._fsp--;
 9245  
 
 9246  344
                                 stream_groupGraphPatternSubDetail.add(groupGraphPatternSubDetail205.getTree());
 9247  
 
 9248  
                                 }
 9249  344
                                 break;
 9250  
 
 9251  
                             default :
 9252  280
                                 if ( cnt67 >= 1 ) break loop67;
 9253  0
                                 EarlyExitException eee =
 9254  
                                     new EarlyExitException(67, input);
 9255  0
                                 throw eee;
 9256  
                         }
 9257  344
                         cnt67++;
 9258  344
                     } while (true);
 9259  
 
 9260  
 
 9261  
                     // AST REWRITE
 9262  
                     // elements: groupGraphPatternSubDetail
 9263  
                     // token labels: 
 9264  
                     // rule labels: retval
 9265  
                     // token list labels: 
 9266  
                     // rule list labels: 
 9267  
                     // wildcard labels: 
 9268  280
                     retval.tree = root_0;
 9269  280
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 9270  
 
 9271  280
                     root_0 = (Object)adaptor.nil();
 9272  
                     // 294:35: -> ( groupGraphPatternSubDetail )+
 9273  
                     {
 9274  280
                         if ( !(stream_groupGraphPatternSubDetail.hasNext()) ) {
 9275  0
                             throw new RewriteEarlyExitException();
 9276  
                         }
 9277  624
                         while ( stream_groupGraphPatternSubDetail.hasNext() ) {
 9278  344
                             adaptor.addChild(root_0, stream_groupGraphPatternSubDetail.nextTree());
 9279  
 
 9280  
                         }
 9281  280
                         stream_groupGraphPatternSubDetail.reset();
 9282  
 
 9283  
                     }
 9284  
 
 9285  
 
 9286  280
                     retval.tree = root_0;
 9287  
 
 9288  
                     }
 9289  
                     break;
 9290  
 
 9291  
             }
 9292  2550
             retval.stop = input.LT(-1);
 9293  
 
 9294  
 
 9295  2550
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 9296  2550
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 9297  
 
 9298  
         }
 9299  0
         catch (RecognitionException re) {
 9300  0
             reportError(re);
 9301  0
             recover(input,re);
 9302  0
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 9303  
 
 9304  
         }
 9305  
 
 9306  0
         finally {
 9307  
                 // do for sure before leaving
 9308  2550
         }
 9309  2550
         return retval;
 9310  
     }
 9311  
     // $ANTLR end "groupGraphPatternSub"
 9312  
 
 9313  
 
 9314  1218
     public static class groupGraphPatternSubDetail_return extends ParserRuleReturnScope {
 9315  
         Object tree;
 9316  1218
         public Object getTree() { return tree; }
 9317  
     };
 9318  
 
 9319  
 
 9320  
     // $ANTLR start "groupGraphPatternSubDetail"
 9321  
     // com\\googlecode\\sparkleg\\Sparql.g:297:1: groupGraphPatternSubDetail : graphPatternNotTriples ( DOT )? ( triplesBlock )? -> graphPatternNotTriples ( triplesBlock )? ;
 9322  
     public final SparqlParser.groupGraphPatternSubDetail_return groupGraphPatternSubDetail() throws RecognitionException {
 9323  1218
         SparqlParser.groupGraphPatternSubDetail_return retval = new SparqlParser.groupGraphPatternSubDetail_return();
 9324  1218
         retval.start = input.LT(1);
 9325  
 
 9326  
 
 9327  1218
         Object root_0 = null;
 9328  
 
 9329  1218
         Token DOT207=null;
 9330  1218
         SparqlParser.graphPatternNotTriples_return graphPatternNotTriples206 =null;
 9331  
 
 9332  1218
         SparqlParser.triplesBlock_return triplesBlock208 =null;
 9333  
 
 9334  
 
 9335  1218
         Object DOT207_tree=null;
 9336  1218
         RewriteRuleTokenStream stream_DOT=new RewriteRuleTokenStream(adaptor,"token DOT");
 9337  1218
         RewriteRuleSubtreeStream stream_triplesBlock=new RewriteRuleSubtreeStream(adaptor,"rule triplesBlock");
 9338  1218
         RewriteRuleSubtreeStream stream_graphPatternNotTriples=new RewriteRuleSubtreeStream(adaptor,"rule graphPatternNotTriples");
 9339  
         try {
 9340  
             // com\\googlecode\\sparkleg\\Sparql.g:298:5: ( graphPatternNotTriples ( DOT )? ( triplesBlock )? -> graphPatternNotTriples ( triplesBlock )? )
 9341  
             // com\\googlecode\\sparkleg\\Sparql.g:298:7: graphPatternNotTriples ( DOT )? ( triplesBlock )?
 9342  
             {
 9343  1218
             pushFollow(FOLLOW_graphPatternNotTriples_in_groupGraphPatternSubDetail2423);
 9344  1218
             graphPatternNotTriples206=graphPatternNotTriples();
 9345  
 
 9346  1218
             state._fsp--;
 9347  
 
 9348  1218
             stream_graphPatternNotTriples.add(graphPatternNotTriples206.getTree());
 9349  
 
 9350  
             // com\\googlecode\\sparkleg\\Sparql.g:298:30: ( DOT )?
 9351  1218
             int alt69=2;
 9352  1218
             switch ( input.LA(1) ) {
 9353  
                 case DOT:
 9354  
                     {
 9355  98
                     alt69=1;
 9356  
                     }
 9357  
                     break;
 9358  
             }
 9359  
 
 9360  1218
             switch (alt69) {
 9361  
                 case 1 :
 9362  
                     // com\\googlecode\\sparkleg\\Sparql.g:298:30: DOT
 9363  
                     {
 9364  98
                     DOT207=(Token)match(input,DOT,FOLLOW_DOT_in_groupGraphPatternSubDetail2425);  
 9365  98
                     stream_DOT.add(DOT207);
 9366  
 
 9367  
 
 9368  
                     }
 9369  
                     break;
 9370  
 
 9371  
             }
 9372  
 
 9373  
 
 9374  
             // com\\googlecode\\sparkleg\\Sparql.g:298:35: ( triplesBlock )?
 9375  1218
             int alt70=2;
 9376  1218
             switch ( input.LA(1) ) {
 9377  
                 case BLANK_NODE_LABEL:
 9378  
                 case DECIMAL:
 9379  
                 case DECIMAL_NEGATIVE:
 9380  
                 case DECIMAL_POSITIVE:
 9381  
                 case DOUBLE:
 9382  
                 case DOUBLE_NEGATIVE:
 9383  
                 case DOUBLE_POSITIVE:
 9384  
                 case FALSE:
 9385  
                 case INTEGER:
 9386  
                 case INTEGER_NEGATIVE:
 9387  
                 case INTEGER_POSITIVE:
 9388  
                 case IRI_REF:
 9389  
                 case OPEN_BRACE:
 9390  
                 case OPEN_SQUARE_BRACKET:
 9391  
                 case PNAME_LN:
 9392  
                 case PNAME_NS:
 9393  
                 case STRING_LITERAL1:
 9394  
                 case STRING_LITERAL2:
 9395  
                 case STRING_LITERAL_LONG1:
 9396  
                 case STRING_LITERAL_LONG2:
 9397  
                 case TRUE:
 9398  
                 case VAR1:
 9399  
                 case VAR2:
 9400  
                     {
 9401  78
                     alt70=1;
 9402  
                     }
 9403  
                     break;
 9404  
             }
 9405  
 
 9406  1218
             switch (alt70) {
 9407  
                 case 1 :
 9408  
                     // com\\googlecode\\sparkleg\\Sparql.g:298:35: triplesBlock
 9409  
                     {
 9410  78
                     pushFollow(FOLLOW_triplesBlock_in_groupGraphPatternSubDetail2428);
 9411  78
                     triplesBlock208=triplesBlock();
 9412  
 
 9413  78
                     state._fsp--;
 9414  
 
 9415  78
                     stream_triplesBlock.add(triplesBlock208.getTree());
 9416  
 
 9417  
                     }
 9418  
                     break;
 9419  
 
 9420  
             }
 9421  
 
 9422  
 
 9423  
             // AST REWRITE
 9424  
             // elements: triplesBlock, graphPatternNotTriples
 9425  
             // token labels: 
 9426  
             // rule labels: retval
 9427  
             // token list labels: 
 9428  
             // rule list labels: 
 9429  
             // wildcard labels: 
 9430  1218
             retval.tree = root_0;
 9431  1218
             RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 9432  
 
 9433  1218
             root_0 = (Object)adaptor.nil();
 9434  
             // 298:49: -> graphPatternNotTriples ( triplesBlock )?
 9435  
             {
 9436  1218
                 adaptor.addChild(root_0, stream_graphPatternNotTriples.nextTree());
 9437  
 
 9438  
                 // com\\googlecode\\sparkleg\\Sparql.g:298:75: ( triplesBlock )?
 9439  1218
                 if ( stream_triplesBlock.hasNext() ) {
 9440  78
                     adaptor.addChild(root_0, stream_triplesBlock.nextTree());
 9441  
 
 9442  
                 }
 9443  1218
                 stream_triplesBlock.reset();
 9444  
 
 9445  
             }
 9446  
 
 9447  
 
 9448  1218
             retval.tree = root_0;
 9449  
 
 9450  
             }
 9451  
 
 9452  1218
             retval.stop = input.LT(-1);
 9453  
 
 9454  
 
 9455  1218
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 9456  1218
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 9457  
 
 9458  
         }
 9459  0
         catch (RecognitionException re) {
 9460  0
             reportError(re);
 9461  0
             recover(input,re);
 9462  0
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 9463  
 
 9464  
         }
 9465  
 
 9466  0
         finally {
 9467  
                 // do for sure before leaving
 9468  1218
         }
 9469  1218
         return retval;
 9470  
     }
 9471  
     // $ANTLR end "groupGraphPatternSubDetail"
 9472  
 
 9473  
 
 9474  2348
     public static class triplesBlock_return extends ParserRuleReturnScope {
 9475  
         Object tree;
 9476  2348
         public Object getTree() { return tree; }
 9477  
     };
 9478  
 
 9479  
 
 9480  
     // $ANTLR start "triplesBlock"
 9481  
     // com\\googlecode\\sparkleg\\Sparql.g:301:1: triplesBlock : triplesSameSubjectPath ( DOT triplesSameSubjectPath )* ( DOT )? -> ( triplesSameSubjectPath )+ ;
 9482  
     public final SparqlParser.triplesBlock_return triplesBlock() throws RecognitionException {
 9483  2348
         SparqlParser.triplesBlock_return retval = new SparqlParser.triplesBlock_return();
 9484  2348
         retval.start = input.LT(1);
 9485  
 
 9486  
 
 9487  2348
         Object root_0 = null;
 9488  
 
 9489  2348
         Token DOT210=null;
 9490  2348
         Token DOT212=null;
 9491  2348
         SparqlParser.triplesSameSubjectPath_return triplesSameSubjectPath209 =null;
 9492  
 
 9493  2348
         SparqlParser.triplesSameSubjectPath_return triplesSameSubjectPath211 =null;
 9494  
 
 9495  
 
 9496  2348
         Object DOT210_tree=null;
 9497  2348
         Object DOT212_tree=null;
 9498  2348
         RewriteRuleTokenStream stream_DOT=new RewriteRuleTokenStream(adaptor,"token DOT");
 9499  2348
         RewriteRuleSubtreeStream stream_triplesSameSubjectPath=new RewriteRuleSubtreeStream(adaptor,"rule triplesSameSubjectPath");
 9500  
         try {
 9501  
             // com\\googlecode\\sparkleg\\Sparql.g:302:5: ( triplesSameSubjectPath ( DOT triplesSameSubjectPath )* ( DOT )? -> ( triplesSameSubjectPath )+ )
 9502  
             // com\\googlecode\\sparkleg\\Sparql.g:302:7: triplesSameSubjectPath ( DOT triplesSameSubjectPath )* ( DOT )?
 9503  
             {
 9504  2348
             pushFollow(FOLLOW_triplesSameSubjectPath_in_triplesBlock2453);
 9505  2348
             triplesSameSubjectPath209=triplesSameSubjectPath();
 9506  
 
 9507  2348
             state._fsp--;
 9508  
 
 9509  2348
             stream_triplesSameSubjectPath.add(triplesSameSubjectPath209.getTree());
 9510  
 
 9511  
             // com\\googlecode\\sparkleg\\Sparql.g:302:30: ( DOT triplesSameSubjectPath )*
 9512  
             loop71:
 9513  
             do {
 9514  2914
                 int alt71=2;
 9515  2914
                 switch ( input.LA(1) ) {
 9516  
                 case DOT:
 9517  
                     {
 9518  1018
                     switch ( input.LA(2) ) {
 9519  
                     case BLANK_NODE_LABEL:
 9520  
                     case DECIMAL:
 9521  
                     case DECIMAL_NEGATIVE:
 9522  
                     case DECIMAL_POSITIVE:
 9523  
                     case DOUBLE:
 9524  
                     case DOUBLE_NEGATIVE:
 9525  
                     case DOUBLE_POSITIVE:
 9526  
                     case FALSE:
 9527  
                     case INTEGER:
 9528  
                     case INTEGER_NEGATIVE:
 9529  
                     case INTEGER_POSITIVE:
 9530  
                     case IRI_REF:
 9531  
                     case OPEN_BRACE:
 9532  
                     case OPEN_SQUARE_BRACKET:
 9533  
                     case PNAME_LN:
 9534  
                     case PNAME_NS:
 9535  
                     case STRING_LITERAL1:
 9536  
                     case STRING_LITERAL2:
 9537  
                     case STRING_LITERAL_LONG1:
 9538  
                     case STRING_LITERAL_LONG2:
 9539  
                     case TRUE:
 9540  
                     case VAR1:
 9541  
                     case VAR2:
 9542  
                         {
 9543  566
                         alt71=1;
 9544  
                         }
 9545  
                         break;
 9546  
 
 9547  
                     }
 9548  
 
 9549  
                     }
 9550  
                     break;
 9551  
 
 9552  
                 }
 9553  
 
 9554  2914
                 switch (alt71) {
 9555  
                     case 1 :
 9556  
                         // com\\googlecode\\sparkleg\\Sparql.g:302:31: DOT triplesSameSubjectPath
 9557  
                         {
 9558  566
                         DOT210=(Token)match(input,DOT,FOLLOW_DOT_in_triplesBlock2456);  
 9559  566
                         stream_DOT.add(DOT210);
 9560  
 
 9561  
 
 9562  566
                         pushFollow(FOLLOW_triplesSameSubjectPath_in_triplesBlock2458);
 9563  566
                         triplesSameSubjectPath211=triplesSameSubjectPath();
 9564  
 
 9565  566
                         state._fsp--;
 9566  
 
 9567  566
                         stream_triplesSameSubjectPath.add(triplesSameSubjectPath211.getTree());
 9568  
 
 9569  
                         }
 9570  566
                         break;
 9571  
 
 9572  
                     default :
 9573  2348
                         break loop71;
 9574  
                 }
 9575  566
             } while (true);
 9576  
 
 9577  
 
 9578  
             // com\\googlecode\\sparkleg\\Sparql.g:302:60: ( DOT )?
 9579  2348
             int alt72=2;
 9580  2348
             switch ( input.LA(1) ) {
 9581  
                 case DOT:
 9582  
                     {
 9583  452
                     alt72=1;
 9584  
                     }
 9585  
                     break;
 9586  
             }
 9587  
 
 9588  2348
             switch (alt72) {
 9589  
                 case 1 :
 9590  
                     // com\\googlecode\\sparkleg\\Sparql.g:302:60: DOT
 9591  
                     {
 9592  452
                     DOT212=(Token)match(input,DOT,FOLLOW_DOT_in_triplesBlock2462);  
 9593  452
                     stream_DOT.add(DOT212);
 9594  
 
 9595  
 
 9596  
                     }
 9597  
                     break;
 9598  
 
 9599  
             }
 9600  
 
 9601  
 
 9602  
             // AST REWRITE
 9603  
             // elements: triplesSameSubjectPath
 9604  
             // token labels: 
 9605  
             // rule labels: retval
 9606  
             // token list labels: 
 9607  
             // rule list labels: 
 9608  
             // wildcard labels: 
 9609  2348
             retval.tree = root_0;
 9610  2348
             RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 9611  
 
 9612  2348
             root_0 = (Object)adaptor.nil();
 9613  
             // 302:65: -> ( triplesSameSubjectPath )+
 9614  
             {
 9615  2348
                 if ( !(stream_triplesSameSubjectPath.hasNext()) ) {
 9616  0
                     throw new RewriteEarlyExitException();
 9617  
                 }
 9618  5262
                 while ( stream_triplesSameSubjectPath.hasNext() ) {
 9619  2914
                     adaptor.addChild(root_0, stream_triplesSameSubjectPath.nextTree());
 9620  
 
 9621  
                 }
 9622  2348
                 stream_triplesSameSubjectPath.reset();
 9623  
 
 9624  
             }
 9625  
 
 9626  
 
 9627  2348
             retval.tree = root_0;
 9628  
 
 9629  
             }
 9630  
 
 9631  2348
             retval.stop = input.LT(-1);
 9632  
 
 9633  
 
 9634  2348
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 9635  2348
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 9636  
 
 9637  
         }
 9638  0
         catch (RecognitionException re) {
 9639  0
             reportError(re);
 9640  0
             recover(input,re);
 9641  0
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 9642  
 
 9643  
         }
 9644  
 
 9645  0
         finally {
 9646  
                 // do for sure before leaving
 9647  2348
         }
 9648  2348
         return retval;
 9649  
     }
 9650  
     // $ANTLR end "triplesBlock"
 9651  
 
 9652  
 
 9653  1218
     public static class graphPatternNotTriples_return extends ParserRuleReturnScope {
 9654  
         Object tree;
 9655  1218
         public Object getTree() { return tree; }
 9656  
     };
 9657  
 
 9658  
 
 9659  
     // $ANTLR start "graphPatternNotTriples"
 9660  
     // com\\googlecode\\sparkleg\\Sparql.g:305:1: graphPatternNotTriples : ( groupOrUnionGraphPattern | optionalGraphPattern | minusGraphPattern | graphGraphPattern | serviceGraphPattern | filter | bind );
 9661  
     public final SparqlParser.graphPatternNotTriples_return graphPatternNotTriples() throws RecognitionException {
 9662  1218
         SparqlParser.graphPatternNotTriples_return retval = new SparqlParser.graphPatternNotTriples_return();
 9663  1218
         retval.start = input.LT(1);
 9664  
 
 9665  
 
 9666  1218
         Object root_0 = null;
 9667  
 
 9668  1218
         SparqlParser.groupOrUnionGraphPattern_return groupOrUnionGraphPattern213 =null;
 9669  
 
 9670  1218
         SparqlParser.optionalGraphPattern_return optionalGraphPattern214 =null;
 9671  
 
 9672  1218
         SparqlParser.minusGraphPattern_return minusGraphPattern215 =null;
 9673  
 
 9674  1218
         SparqlParser.graphGraphPattern_return graphGraphPattern216 =null;
 9675  
 
 9676  1218
         SparqlParser.serviceGraphPattern_return serviceGraphPattern217 =null;
 9677  
 
 9678  1218
         SparqlParser.filter_return filter218 =null;
 9679  
 
 9680  1218
         SparqlParser.bind_return bind219 =null;
 9681  
 
 9682  
 
 9683  
 
 9684  
         try {
 9685  
             // com\\googlecode\\sparkleg\\Sparql.g:306:5: ( groupOrUnionGraphPattern | optionalGraphPattern | minusGraphPattern | graphGraphPattern | serviceGraphPattern | filter | bind )
 9686  1218
             int alt73=7;
 9687  1218
             switch ( input.LA(1) ) {
 9688  
             case OPEN_CURLY_BRACE:
 9689  
                 {
 9690  176
                 alt73=1;
 9691  
                 }
 9692  176
                 break;
 9693  
             case OPTIONAL:
 9694  
                 {
 9695  188
                 alt73=2;
 9696  
                 }
 9697  188
                 break;
 9698  
             case MINUS_KEYWORD:
 9699  
                 {
 9700  42
                 alt73=3;
 9701  
                 }
 9702  42
                 break;
 9703  
             case GRAPH:
 9704  
                 {
 9705  152
                 alt73=4;
 9706  
                 }
 9707  152
                 break;
 9708  
             case SERVICE:
 9709  
                 {
 9710  26
                 alt73=5;
 9711  
                 }
 9712  26
                 break;
 9713  
             case FILTER:
 9714  
                 {
 9715  584
                 alt73=6;
 9716  
                 }
 9717  584
                 break;
 9718  
             case BIND:
 9719  
                 {
 9720  50
                 alt73=7;
 9721  
                 }
 9722  50
                 break;
 9723  
             default:
 9724  0
                 NoViableAltException nvae =
 9725  
                     new NoViableAltException("", 73, 0, input);
 9726  
 
 9727  0
                 throw nvae;
 9728  
 
 9729  
             }
 9730  
 
 9731  1218
             switch (alt73) {
 9732  
                 case 1 :
 9733  
                     // com\\googlecode\\sparkleg\\Sparql.g:306:7: groupOrUnionGraphPattern
 9734  
                     {
 9735  176
                     root_0 = (Object)adaptor.nil();
 9736  
 
 9737  
 
 9738  176
                     pushFollow(FOLLOW_groupOrUnionGraphPattern_in_graphPatternNotTriples2485);
 9739  176
                     groupOrUnionGraphPattern213=groupOrUnionGraphPattern();
 9740  
 
 9741  176
                     state._fsp--;
 9742  
 
 9743  176
                     adaptor.addChild(root_0, groupOrUnionGraphPattern213.getTree());
 9744  
 
 9745  
                     }
 9746  176
                     break;
 9747  
                 case 2 :
 9748  
                     // com\\googlecode\\sparkleg\\Sparql.g:306:34: optionalGraphPattern
 9749  
                     {
 9750  188
                     root_0 = (Object)adaptor.nil();
 9751  
 
 9752  
 
 9753  188
                     pushFollow(FOLLOW_optionalGraphPattern_in_graphPatternNotTriples2489);
 9754  188
                     optionalGraphPattern214=optionalGraphPattern();
 9755  
 
 9756  188
                     state._fsp--;
 9757  
 
 9758  188
                     adaptor.addChild(root_0, optionalGraphPattern214.getTree());
 9759  
 
 9760  
                     }
 9761  188
                     break;
 9762  
                 case 3 :
 9763  
                     // com\\googlecode\\sparkleg\\Sparql.g:306:57: minusGraphPattern
 9764  
                     {
 9765  42
                     root_0 = (Object)adaptor.nil();
 9766  
 
 9767  
 
 9768  42
                     pushFollow(FOLLOW_minusGraphPattern_in_graphPatternNotTriples2493);
 9769  42
                     minusGraphPattern215=minusGraphPattern();
 9770  
 
 9771  42
                     state._fsp--;
 9772  
 
 9773  42
                     adaptor.addChild(root_0, minusGraphPattern215.getTree());
 9774  
 
 9775  
                     }
 9776  42
                     break;
 9777  
                 case 4 :
 9778  
                     // com\\googlecode\\sparkleg\\Sparql.g:306:77: graphGraphPattern
 9779  
                     {
 9780  152
                     root_0 = (Object)adaptor.nil();
 9781  
 
 9782  
 
 9783  152
                     pushFollow(FOLLOW_graphGraphPattern_in_graphPatternNotTriples2497);
 9784  152
                     graphGraphPattern216=graphGraphPattern();
 9785  
 
 9786  152
                     state._fsp--;
 9787  
 
 9788  152
                     adaptor.addChild(root_0, graphGraphPattern216.getTree());
 9789  
 
 9790  
                     }
 9791  152
                     break;
 9792  
                 case 5 :
 9793  
                     // com\\googlecode\\sparkleg\\Sparql.g:306:97: serviceGraphPattern
 9794  
                     {
 9795  26
                     root_0 = (Object)adaptor.nil();
 9796  
 
 9797  
 
 9798  26
                     pushFollow(FOLLOW_serviceGraphPattern_in_graphPatternNotTriples2501);
 9799  26
                     serviceGraphPattern217=serviceGraphPattern();
 9800  
 
 9801  26
                     state._fsp--;
 9802  
 
 9803  26
                     adaptor.addChild(root_0, serviceGraphPattern217.getTree());
 9804  
 
 9805  
                     }
 9806  26
                     break;
 9807  
                 case 6 :
 9808  
                     // com\\googlecode\\sparkleg\\Sparql.g:306:119: filter
 9809  
                     {
 9810  584
                     root_0 = (Object)adaptor.nil();
 9811  
 
 9812  
 
 9813  584
                     pushFollow(FOLLOW_filter_in_graphPatternNotTriples2505);
 9814  584
                     filter218=filter();
 9815  
 
 9816  584
                     state._fsp--;
 9817  
 
 9818  584
                     adaptor.addChild(root_0, filter218.getTree());
 9819  
 
 9820  
                     }
 9821  584
                     break;
 9822  
                 case 7 :
 9823  
                     // com\\googlecode\\sparkleg\\Sparql.g:306:128: bind
 9824  
                     {
 9825  50
                     root_0 = (Object)adaptor.nil();
 9826  
 
 9827  
 
 9828  50
                     pushFollow(FOLLOW_bind_in_graphPatternNotTriples2509);
 9829  50
                     bind219=bind();
 9830  
 
 9831  50
                     state._fsp--;
 9832  
 
 9833  50
                     adaptor.addChild(root_0, bind219.getTree());
 9834  
 
 9835  
                     }
 9836  
                     break;
 9837  
 
 9838  
             }
 9839  1218
             retval.stop = input.LT(-1);
 9840  
 
 9841  
 
 9842  1218
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 9843  1218
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 9844  
 
 9845  
         }
 9846  0
         catch (RecognitionException re) {
 9847  0
             reportError(re);
 9848  0
             recover(input,re);
 9849  0
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 9850  
 
 9851  
         }
 9852  
 
 9853  0
         finally {
 9854  
                 // do for sure before leaving
 9855  1218
         }
 9856  1218
         return retval;
 9857  
     }
 9858  
     // $ANTLR end "graphPatternNotTriples"
 9859  
 
 9860  
 
 9861  188
     public static class optionalGraphPattern_return extends ParserRuleReturnScope {
 9862  
         Object tree;
 9863  188
         public Object getTree() { return tree; }
 9864  
     };
 9865  
 
 9866  
 
 9867  
     // $ANTLR start "optionalGraphPattern"
 9868  
     // com\\googlecode\\sparkleg\\Sparql.g:309:1: optionalGraphPattern : OPTIONAL groupGraphPattern -> ^( OPTIONAL groupGraphPattern ) ;
 9869  
     public final SparqlParser.optionalGraphPattern_return optionalGraphPattern() throws RecognitionException {
 9870  188
         SparqlParser.optionalGraphPattern_return retval = new SparqlParser.optionalGraphPattern_return();
 9871  188
         retval.start = input.LT(1);
 9872  
 
 9873  
 
 9874  188
         Object root_0 = null;
 9875  
 
 9876  188
         Token OPTIONAL220=null;
 9877  188
         SparqlParser.groupGraphPattern_return groupGraphPattern221 =null;
 9878  
 
 9879  
 
 9880  188
         Object OPTIONAL220_tree=null;
 9881  188
         RewriteRuleTokenStream stream_OPTIONAL=new RewriteRuleTokenStream(adaptor,"token OPTIONAL");
 9882  188
         RewriteRuleSubtreeStream stream_groupGraphPattern=new RewriteRuleSubtreeStream(adaptor,"rule groupGraphPattern");
 9883  
         try {
 9884  
             // com\\googlecode\\sparkleg\\Sparql.g:310:5: ( OPTIONAL groupGraphPattern -> ^( OPTIONAL groupGraphPattern ) )
 9885  
             // com\\googlecode\\sparkleg\\Sparql.g:310:7: OPTIONAL groupGraphPattern
 9886  
             {
 9887  188
             OPTIONAL220=(Token)match(input,OPTIONAL,FOLLOW_OPTIONAL_in_optionalGraphPattern2526);  
 9888  188
             stream_OPTIONAL.add(OPTIONAL220);
 9889  
 
 9890  
 
 9891  188
             pushFollow(FOLLOW_groupGraphPattern_in_optionalGraphPattern2528);
 9892  188
             groupGraphPattern221=groupGraphPattern();
 9893  
 
 9894  188
             state._fsp--;
 9895  
 
 9896  188
             stream_groupGraphPattern.add(groupGraphPattern221.getTree());
 9897  
 
 9898  
             // AST REWRITE
 9899  
             // elements: groupGraphPattern, OPTIONAL
 9900  
             // token labels: 
 9901  
             // rule labels: retval
 9902  
             // token list labels: 
 9903  
             // rule list labels: 
 9904  
             // wildcard labels: 
 9905  188
             retval.tree = root_0;
 9906  188
             RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 9907  
 
 9908  188
             root_0 = (Object)adaptor.nil();
 9909  
             // 310:34: -> ^( OPTIONAL groupGraphPattern )
 9910  
             {
 9911  
                 // com\\googlecode\\sparkleg\\Sparql.g:310:37: ^( OPTIONAL groupGraphPattern )
 9912  
                 {
 9913  188
                 Object root_1 = (Object)adaptor.nil();
 9914  188
                 root_1 = (Object)adaptor.becomeRoot(
 9915  
                 stream_OPTIONAL.nextNode()
 9916  
                 , root_1);
 9917  
 
 9918  188
                 adaptor.addChild(root_1, stream_groupGraphPattern.nextTree());
 9919  
 
 9920  188
                 adaptor.addChild(root_0, root_1);
 9921  
                 }
 9922  
 
 9923  
             }
 9924  
 
 9925  
 
 9926  188
             retval.tree = root_0;
 9927  
 
 9928  
             }
 9929  
 
 9930  188
             retval.stop = input.LT(-1);
 9931  
 
 9932  
 
 9933  188
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 9934  188
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 9935  
 
 9936  
         }
 9937  0
         catch (RecognitionException re) {
 9938  0
             reportError(re);
 9939  0
             recover(input,re);
 9940  0
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 9941  
 
 9942  
         }
 9943  
 
 9944  0
         finally {
 9945  
                 // do for sure before leaving
 9946  188
         }
 9947  188
         return retval;
 9948  
     }
 9949  
     // $ANTLR end "optionalGraphPattern"
 9950  
 
 9951  
 
 9952  152
     public static class graphGraphPattern_return extends ParserRuleReturnScope {
 9953  
         Object tree;
 9954  152
         public Object getTree() { return tree; }
 9955  
     };
 9956  
 
 9957  
 
 9958  
     // $ANTLR start "graphGraphPattern"
 9959  
     // com\\googlecode\\sparkleg\\Sparql.g:313:1: graphGraphPattern : GRAPH varOrIRIref groupGraphPattern -> ^( GRAPH varOrIRIref groupGraphPattern ) ;
 9960  
     public final SparqlParser.graphGraphPattern_return graphGraphPattern() throws RecognitionException {
 9961  152
         SparqlParser.graphGraphPattern_return retval = new SparqlParser.graphGraphPattern_return();
 9962  152
         retval.start = input.LT(1);
 9963  
 
 9964  
 
 9965  152
         Object root_0 = null;
 9966  
 
 9967  152
         Token GRAPH222=null;
 9968  152
         SparqlParser.varOrIRIref_return varOrIRIref223 =null;
 9969  
 
 9970  152
         SparqlParser.groupGraphPattern_return groupGraphPattern224 =null;
 9971  
 
 9972  
 
 9973  152
         Object GRAPH222_tree=null;
 9974  152
         RewriteRuleTokenStream stream_GRAPH=new RewriteRuleTokenStream(adaptor,"token GRAPH");
 9975  152
         RewriteRuleSubtreeStream stream_varOrIRIref=new RewriteRuleSubtreeStream(adaptor,"rule varOrIRIref");
 9976  152
         RewriteRuleSubtreeStream stream_groupGraphPattern=new RewriteRuleSubtreeStream(adaptor,"rule groupGraphPattern");
 9977  
         try {
 9978  
             // com\\googlecode\\sparkleg\\Sparql.g:314:5: ( GRAPH varOrIRIref groupGraphPattern -> ^( GRAPH varOrIRIref groupGraphPattern ) )
 9979  
             // com\\googlecode\\sparkleg\\Sparql.g:314:7: GRAPH varOrIRIref groupGraphPattern
 9980  
             {
 9981  152
             GRAPH222=(Token)match(input,GRAPH,FOLLOW_GRAPH_in_graphGraphPattern2553);  
 9982  152
             stream_GRAPH.add(GRAPH222);
 9983  
 
 9984  
 
 9985  152
             pushFollow(FOLLOW_varOrIRIref_in_graphGraphPattern2555);
 9986  152
             varOrIRIref223=varOrIRIref();
 9987  
 
 9988  152
             state._fsp--;
 9989  
 
 9990  152
             stream_varOrIRIref.add(varOrIRIref223.getTree());
 9991  
 
 9992  152
             pushFollow(FOLLOW_groupGraphPattern_in_graphGraphPattern2557);
 9993  152
             groupGraphPattern224=groupGraphPattern();
 9994  
 
 9995  152
             state._fsp--;
 9996  
 
 9997  152
             stream_groupGraphPattern.add(groupGraphPattern224.getTree());
 9998  
 
 9999  
             // AST REWRITE
 10000  
             // elements: varOrIRIref, GRAPH, groupGraphPattern
 10001  
             // token labels: 
 10002  
             // rule labels: retval
 10003  
             // token list labels: 
 10004  
             // rule list labels: 
 10005  
             // wildcard labels: 
 10006  152
             retval.tree = root_0;
 10007  152
             RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 10008  
 
 10009  152
             root_0 = (Object)adaptor.nil();
 10010  
             // 314:43: -> ^( GRAPH varOrIRIref groupGraphPattern )
 10011  
             {
 10012  
                 // com\\googlecode\\sparkleg\\Sparql.g:314:46: ^( GRAPH varOrIRIref groupGraphPattern )
 10013  
                 {
 10014  152
                 Object root_1 = (Object)adaptor.nil();
 10015  152
                 root_1 = (Object)adaptor.becomeRoot(
 10016  
                 stream_GRAPH.nextNode()
 10017  
                 , root_1);
 10018  
 
 10019  152
                 adaptor.addChild(root_1, stream_varOrIRIref.nextTree());
 10020  
 
 10021  152
                 adaptor.addChild(root_1, stream_groupGraphPattern.nextTree());
 10022  
 
 10023  152
                 adaptor.addChild(root_0, root_1);
 10024  
                 }
 10025  
 
 10026  
             }
 10027  
 
 10028  
 
 10029  152
             retval.tree = root_0;
 10030  
 
 10031  
             }
 10032  
 
 10033  152
             retval.stop = input.LT(-1);
 10034  
 
 10035  
 
 10036  152
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 10037  152
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 10038  
 
 10039  
         }
 10040  0
         catch (RecognitionException re) {
 10041  0
             reportError(re);
 10042  0
             recover(input,re);
 10043  0
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 10044  
 
 10045  
         }
 10046  
 
 10047  0
         finally {
 10048  
                 // do for sure before leaving
 10049  152
         }
 10050  152
         return retval;
 10051  
     }
 10052  
     // $ANTLR end "graphGraphPattern"
 10053  
 
 10054  
 
 10055  26
     public static class serviceGraphPattern_return extends ParserRuleReturnScope {
 10056  
         Object tree;
 10057  26
         public Object getTree() { return tree; }
 10058  
     };
 10059  
 
 10060  
 
 10061  
     // $ANTLR start "serviceGraphPattern"
 10062  
     // com\\googlecode\\sparkleg\\Sparql.g:317:1: serviceGraphPattern : SERVICE ( SILENT )? varOrIRIref groupGraphPattern -> ^( SERVICE ( SILENT )? varOrIRIref groupGraphPattern ) ;
 10063  
     public final SparqlParser.serviceGraphPattern_return serviceGraphPattern() throws RecognitionException {
 10064  26
         SparqlParser.serviceGraphPattern_return retval = new SparqlParser.serviceGraphPattern_return();
 10065  26
         retval.start = input.LT(1);
 10066  
 
 10067  
 
 10068  26
         Object root_0 = null;
 10069  
 
 10070  26
         Token SERVICE225=null;
 10071  26
         Token SILENT226=null;
 10072  26
         SparqlParser.varOrIRIref_return varOrIRIref227 =null;
 10073  
 
 10074  26
         SparqlParser.groupGraphPattern_return groupGraphPattern228 =null;
 10075  
 
 10076  
 
 10077  26
         Object SERVICE225_tree=null;
 10078  26
         Object SILENT226_tree=null;
 10079  26
         RewriteRuleTokenStream stream_SILENT=new RewriteRuleTokenStream(adaptor,"token SILENT");
 10080  26
         RewriteRuleTokenStream stream_SERVICE=new RewriteRuleTokenStream(adaptor,"token SERVICE");
 10081  26
         RewriteRuleSubtreeStream stream_varOrIRIref=new RewriteRuleSubtreeStream(adaptor,"rule varOrIRIref");
 10082  26
         RewriteRuleSubtreeStream stream_groupGraphPattern=new RewriteRuleSubtreeStream(adaptor,"rule groupGraphPattern");
 10083  
         try {
 10084  
             // com\\googlecode\\sparkleg\\Sparql.g:318:5: ( SERVICE ( SILENT )? varOrIRIref groupGraphPattern -> ^( SERVICE ( SILENT )? varOrIRIref groupGraphPattern ) )
 10085  
             // com\\googlecode\\sparkleg\\Sparql.g:318:7: SERVICE ( SILENT )? varOrIRIref groupGraphPattern
 10086  
             {
 10087  26
             SERVICE225=(Token)match(input,SERVICE,FOLLOW_SERVICE_in_serviceGraphPattern2584);  
 10088  26
             stream_SERVICE.add(SERVICE225);
 10089  
 
 10090  
 
 10091  
             // com\\googlecode\\sparkleg\\Sparql.g:318:15: ( SILENT )?
 10092  26
             int alt74=2;
 10093  26
             switch ( input.LA(1) ) {
 10094  
                 case SILENT:
 10095  
                     {
 10096  6
                     alt74=1;
 10097  
                     }
 10098  
                     break;
 10099  
             }
 10100  
 
 10101  26
             switch (alt74) {
 10102  
                 case 1 :
 10103  
                     // com\\googlecode\\sparkleg\\Sparql.g:318:15: SILENT
 10104  
                     {
 10105  6
                     SILENT226=(Token)match(input,SILENT,FOLLOW_SILENT_in_serviceGraphPattern2586);  
 10106  6
                     stream_SILENT.add(SILENT226);
 10107  
 
 10108  
 
 10109  
                     }
 10110  
                     break;
 10111  
 
 10112  
             }
 10113  
 
 10114  
 
 10115  26
             pushFollow(FOLLOW_varOrIRIref_in_serviceGraphPattern2589);
 10116  26
             varOrIRIref227=varOrIRIref();
 10117  
 
 10118  26
             state._fsp--;
 10119  
 
 10120  26
             stream_varOrIRIref.add(varOrIRIref227.getTree());
 10121  
 
 10122  26
             pushFollow(FOLLOW_groupGraphPattern_in_serviceGraphPattern2591);
 10123  26
             groupGraphPattern228=groupGraphPattern();
 10124  
 
 10125  26
             state._fsp--;
 10126  
 
 10127  26
             stream_groupGraphPattern.add(groupGraphPattern228.getTree());
 10128  
 
 10129  
             // AST REWRITE
 10130  
             // elements: groupGraphPattern, SERVICE, SILENT, varOrIRIref
 10131  
             // token labels: 
 10132  
             // rule labels: retval
 10133  
             // token list labels: 
 10134  
             // rule list labels: 
 10135  
             // wildcard labels: 
 10136  26
             retval.tree = root_0;
 10137  26
             RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 10138  
 
 10139  26
             root_0 = (Object)adaptor.nil();
 10140  
             // 318:53: -> ^( SERVICE ( SILENT )? varOrIRIref groupGraphPattern )
 10141  
             {
 10142  
                 // com\\googlecode\\sparkleg\\Sparql.g:318:56: ^( SERVICE ( SILENT )? varOrIRIref groupGraphPattern )
 10143  
                 {
 10144  26
                 Object root_1 = (Object)adaptor.nil();
 10145  26
                 root_1 = (Object)adaptor.becomeRoot(
 10146  
                 stream_SERVICE.nextNode()
 10147  
                 , root_1);
 10148  
 
 10149  
                 // com\\googlecode\\sparkleg\\Sparql.g:318:66: ( SILENT )?
 10150  26
                 if ( stream_SILENT.hasNext() ) {
 10151  6
                     adaptor.addChild(root_1, 
 10152  
                     stream_SILENT.nextNode()
 10153  
                     );
 10154  
 
 10155  
                 }
 10156  26
                 stream_SILENT.reset();
 10157  
 
 10158  26
                 adaptor.addChild(root_1, stream_varOrIRIref.nextTree());
 10159  
 
 10160  26
                 adaptor.addChild(root_1, stream_groupGraphPattern.nextTree());
 10161  
 
 10162  26
                 adaptor.addChild(root_0, root_1);
 10163  
                 }
 10164  
 
 10165  
             }
 10166  
 
 10167  
 
 10168  26
             retval.tree = root_0;
 10169  
 
 10170  
             }
 10171  
 
 10172  26
             retval.stop = input.LT(-1);
 10173  
 
 10174  
 
 10175  26
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 10176  26
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 10177  
 
 10178  
         }
 10179  0
         catch (RecognitionException re) {
 10180  0
             reportError(re);
 10181  0
             recover(input,re);
 10182  0
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 10183  
 
 10184  
         }
 10185  
 
 10186  0
         finally {
 10187  
                 // do for sure before leaving
 10188  26
         }
 10189  26
         return retval;
 10190  
     }
 10191  
     // $ANTLR end "serviceGraphPattern"
 10192  
 
 10193  
 
 10194  50
     public static class bind_return extends ParserRuleReturnScope {
 10195  
         Object tree;
 10196  50
         public Object getTree() { return tree; }
 10197  
     };
 10198  
 
 10199  
 
 10200  
     // $ANTLR start "bind"
 10201  
     // com\\googlecode\\sparkleg\\Sparql.g:321:1: bind : BIND OPEN_BRACE expression AS var CLOSE_BRACE -> ^( BIND expression ^( AS var ) ) ;
 10202  
     public final SparqlParser.bind_return bind() throws RecognitionException {
 10203  50
         SparqlParser.bind_return retval = new SparqlParser.bind_return();
 10204  50
         retval.start = input.LT(1);
 10205  
 
 10206  
 
 10207  50
         Object root_0 = null;
 10208  
 
 10209  50
         Token BIND229=null;
 10210  50
         Token OPEN_BRACE230=null;
 10211  50
         Token AS232=null;
 10212  50
         Token CLOSE_BRACE234=null;
 10213  50
         SparqlParser.expression_return expression231 =null;
 10214  
 
 10215  50
         SparqlParser.var_return var233 =null;
 10216  
 
 10217  
 
 10218  50
         Object BIND229_tree=null;
 10219  50
         Object OPEN_BRACE230_tree=null;
 10220  50
         Object AS232_tree=null;
 10221  50
         Object CLOSE_BRACE234_tree=null;
 10222  50
         RewriteRuleTokenStream stream_AS=new RewriteRuleTokenStream(adaptor,"token AS");
 10223  50
         RewriteRuleTokenStream stream_CLOSE_BRACE=new RewriteRuleTokenStream(adaptor,"token CLOSE_BRACE");
 10224  50
         RewriteRuleTokenStream stream_BIND=new RewriteRuleTokenStream(adaptor,"token BIND");
 10225  50
         RewriteRuleTokenStream stream_OPEN_BRACE=new RewriteRuleTokenStream(adaptor,"token OPEN_BRACE");
 10226  50
         RewriteRuleSubtreeStream stream_expression=new RewriteRuleSubtreeStream(adaptor,"rule expression");
 10227  50
         RewriteRuleSubtreeStream stream_var=new RewriteRuleSubtreeStream(adaptor,"rule var");
 10228  
         try {
 10229  
             // com\\googlecode\\sparkleg\\Sparql.g:322:5: ( BIND OPEN_BRACE expression AS var CLOSE_BRACE -> ^( BIND expression ^( AS var ) ) )
 10230  
             // com\\googlecode\\sparkleg\\Sparql.g:322:7: BIND OPEN_BRACE expression AS var CLOSE_BRACE
 10231  
             {
 10232  50
             BIND229=(Token)match(input,BIND,FOLLOW_BIND_in_bind2625);  
 10233  50
             stream_BIND.add(BIND229);
 10234  
 
 10235  
 
 10236  50
             OPEN_BRACE230=(Token)match(input,OPEN_BRACE,FOLLOW_OPEN_BRACE_in_bind2627);  
 10237  50
             stream_OPEN_BRACE.add(OPEN_BRACE230);
 10238  
 
 10239  
 
 10240  50
             pushFollow(FOLLOW_expression_in_bind2629);
 10241  50
             expression231=expression();
 10242  
 
 10243  50
             state._fsp--;
 10244  
 
 10245  50
             stream_expression.add(expression231.getTree());
 10246  
 
 10247  50
             AS232=(Token)match(input,AS,FOLLOW_AS_in_bind2631);  
 10248  50
             stream_AS.add(AS232);
 10249  
 
 10250  
 
 10251  50
             pushFollow(FOLLOW_var_in_bind2633);
 10252  50
             var233=var();
 10253  
 
 10254  50
             state._fsp--;
 10255  
 
 10256  50
             stream_var.add(var233.getTree());
 10257  
 
 10258  50
             CLOSE_BRACE234=(Token)match(input,CLOSE_BRACE,FOLLOW_CLOSE_BRACE_in_bind2635);  
 10259  50
             stream_CLOSE_BRACE.add(CLOSE_BRACE234);
 10260  
 
 10261  
 
 10262  
             // AST REWRITE
 10263  
             // elements: expression, var, AS, BIND
 10264  
             // token labels: 
 10265  
             // rule labels: retval
 10266  
             // token list labels: 
 10267  
             // rule list labels: 
 10268  
             // wildcard labels: 
 10269  50
             retval.tree = root_0;
 10270  50
             RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 10271  
 
 10272  50
             root_0 = (Object)adaptor.nil();
 10273  
             // 322:53: -> ^( BIND expression ^( AS var ) )
 10274  
             {
 10275  
                 // com\\googlecode\\sparkleg\\Sparql.g:322:56: ^( BIND expression ^( AS var ) )
 10276  
                 {
 10277  50
                 Object root_1 = (Object)adaptor.nil();
 10278  50
                 root_1 = (Object)adaptor.becomeRoot(
 10279  
                 stream_BIND.nextNode()
 10280  
                 , root_1);
 10281  
 
 10282  50
                 adaptor.addChild(root_1, stream_expression.nextTree());
 10283  
 
 10284  
                 // com\\googlecode\\sparkleg\\Sparql.g:322:74: ^( AS var )
 10285  
                 {
 10286  50
                 Object root_2 = (Object)adaptor.nil();
 10287  50
                 root_2 = (Object)adaptor.becomeRoot(
 10288  
                 stream_AS.nextNode()
 10289  
                 , root_2);
 10290  
 
 10291  50
                 adaptor.addChild(root_2, stream_var.nextTree());
 10292  
 
 10293  50
                 adaptor.addChild(root_1, root_2);
 10294  
                 }
 10295  
 
 10296  50
                 adaptor.addChild(root_0, root_1);
 10297  
                 }
 10298  
 
 10299  
             }
 10300  
 
 10301  
 
 10302  50
             retval.tree = root_0;
 10303  
 
 10304  
             }
 10305  
 
 10306  50
             retval.stop = input.LT(-1);
 10307  
 
 10308  
 
 10309  50
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 10310  50
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 10311  
 
 10312  
         }
 10313  0
         catch (RecognitionException re) {
 10314  0
             reportError(re);
 10315  0
             recover(input,re);
 10316  0
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 10317  
 
 10318  
         }
 10319  
 
 10320  0
         finally {
 10321  
                 // do for sure before leaving
 10322  50
         }
 10323  50
         return retval;
 10324  
     }
 10325  
     // $ANTLR end "bind"
 10326  
 
 10327  
 
 10328  42
     public static class minusGraphPattern_return extends ParserRuleReturnScope {
 10329  
         Object tree;
 10330  42
         public Object getTree() { return tree; }
 10331  
     };
 10332  
 
 10333  
 
 10334  
     // $ANTLR start "minusGraphPattern"
 10335  
     // com\\googlecode\\sparkleg\\Sparql.g:325:1: minusGraphPattern : MINUS_KEYWORD groupGraphPattern -> ^( MINUS_KEYWORD groupGraphPattern ) ;
 10336  
     public final SparqlParser.minusGraphPattern_return minusGraphPattern() throws RecognitionException {
 10337  42
         SparqlParser.minusGraphPattern_return retval = new SparqlParser.minusGraphPattern_return();
 10338  42
         retval.start = input.LT(1);
 10339  
 
 10340  
 
 10341  42
         Object root_0 = null;
 10342  
 
 10343  42
         Token MINUS_KEYWORD235=null;
 10344  42
         SparqlParser.groupGraphPattern_return groupGraphPattern236 =null;
 10345  
 
 10346  
 
 10347  42
         Object MINUS_KEYWORD235_tree=null;
 10348  42
         RewriteRuleTokenStream stream_MINUS_KEYWORD=new RewriteRuleTokenStream(adaptor,"token MINUS_KEYWORD");
 10349  42
         RewriteRuleSubtreeStream stream_groupGraphPattern=new RewriteRuleSubtreeStream(adaptor,"rule groupGraphPattern");
 10350  
         try {
 10351  
             // com\\googlecode\\sparkleg\\Sparql.g:326:5: ( MINUS_KEYWORD groupGraphPattern -> ^( MINUS_KEYWORD groupGraphPattern ) )
 10352  
             // com\\googlecode\\sparkleg\\Sparql.g:326:7: MINUS_KEYWORD groupGraphPattern
 10353  
             {
 10354  42
             MINUS_KEYWORD235=(Token)match(input,MINUS_KEYWORD,FOLLOW_MINUS_KEYWORD_in_minusGraphPattern2672);  
 10355  42
             stream_MINUS_KEYWORD.add(MINUS_KEYWORD235);
 10356  
 
 10357  
 
 10358  42
             pushFollow(FOLLOW_groupGraphPattern_in_minusGraphPattern2674);
 10359  42
             groupGraphPattern236=groupGraphPattern();
 10360  
 
 10361  42
             state._fsp--;
 10362  
 
 10363  42
             stream_groupGraphPattern.add(groupGraphPattern236.getTree());
 10364  
 
 10365  
             // AST REWRITE
 10366  
             // elements: groupGraphPattern, MINUS_KEYWORD
 10367  
             // token labels: 
 10368  
             // rule labels: retval
 10369  
             // token list labels: 
 10370  
             // rule list labels: 
 10371  
             // wildcard labels: 
 10372  42
             retval.tree = root_0;
 10373  42
             RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 10374  
 
 10375  42
             root_0 = (Object)adaptor.nil();
 10376  
             // 326:39: -> ^( MINUS_KEYWORD groupGraphPattern )
 10377  
             {
 10378  
                 // com\\googlecode\\sparkleg\\Sparql.g:326:42: ^( MINUS_KEYWORD groupGraphPattern )
 10379  
                 {
 10380  42
                 Object root_1 = (Object)adaptor.nil();
 10381  42
                 root_1 = (Object)adaptor.becomeRoot(
 10382  
                 stream_MINUS_KEYWORD.nextNode()
 10383  
                 , root_1);
 10384  
 
 10385  42
                 adaptor.addChild(root_1, stream_groupGraphPattern.nextTree());
 10386  
 
 10387  42
                 adaptor.addChild(root_0, root_1);
 10388  
                 }
 10389  
 
 10390  
             }
 10391  
 
 10392  
 
 10393  42
             retval.tree = root_0;
 10394  
 
 10395  
             }
 10396  
 
 10397  42
             retval.stop = input.LT(-1);
 10398  
 
 10399  
 
 10400  42
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 10401  42
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 10402  
 
 10403  
         }
 10404  0
         catch (RecognitionException re) {
 10405  0
             reportError(re);
 10406  0
             recover(input,re);
 10407  0
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 10408  
 
 10409  
         }
 10410  
 
 10411  0
         finally {
 10412  
                 // do for sure before leaving
 10413  42
         }
 10414  42
         return retval;
 10415  
     }
 10416  
     // $ANTLR end "minusGraphPattern"
 10417  
 
 10418  
 
 10419  176
     public static class groupOrUnionGraphPattern_return extends ParserRuleReturnScope {
 10420  
         Object tree;
 10421  176
         public Object getTree() { return tree; }
 10422  
     };
 10423  
 
 10424  
 
 10425  
     // $ANTLR start "groupOrUnionGraphPattern"
 10426  
     // com\\googlecode\\sparkleg\\Sparql.g:329:1: groupOrUnionGraphPattern : (g1= groupGraphPattern -> $g1) ( ( UNION g2= groupGraphPattern ) -> ^( UNION $groupOrUnionGraphPattern $g2) )* ;
 10427  
     public final SparqlParser.groupOrUnionGraphPattern_return groupOrUnionGraphPattern() throws RecognitionException {
 10428  176
         SparqlParser.groupOrUnionGraphPattern_return retval = new SparqlParser.groupOrUnionGraphPattern_return();
 10429  176
         retval.start = input.LT(1);
 10430  
 
 10431  
 
 10432  176
         Object root_0 = null;
 10433  
 
 10434  176
         Token UNION237=null;
 10435  176
         SparqlParser.groupGraphPattern_return g1 =null;
 10436  
 
 10437  176
         SparqlParser.groupGraphPattern_return g2 =null;
 10438  
 
 10439  
 
 10440  176
         Object UNION237_tree=null;
 10441  176
         RewriteRuleTokenStream stream_UNION=new RewriteRuleTokenStream(adaptor,"token UNION");
 10442  176
         RewriteRuleSubtreeStream stream_groupGraphPattern=new RewriteRuleSubtreeStream(adaptor,"rule groupGraphPattern");
 10443  
         try {
 10444  
             // com\\googlecode\\sparkleg\\Sparql.g:330:5: ( (g1= groupGraphPattern -> $g1) ( ( UNION g2= groupGraphPattern ) -> ^( UNION $groupOrUnionGraphPattern $g2) )* )
 10445  
             // com\\googlecode\\sparkleg\\Sparql.g:330:7: (g1= groupGraphPattern -> $g1) ( ( UNION g2= groupGraphPattern ) -> ^( UNION $groupOrUnionGraphPattern $g2) )*
 10446  
             {
 10447  
             // com\\googlecode\\sparkleg\\Sparql.g:330:7: (g1= groupGraphPattern -> $g1)
 10448  
             // com\\googlecode\\sparkleg\\Sparql.g:330:8: g1= groupGraphPattern
 10449  
             {
 10450  176
             pushFollow(FOLLOW_groupGraphPattern_in_groupOrUnionGraphPattern2702);
 10451  176
             g1=groupGraphPattern();
 10452  
 
 10453  176
             state._fsp--;
 10454  
 
 10455  176
             stream_groupGraphPattern.add(g1.getTree());
 10456  
 
 10457  
             // AST REWRITE
 10458  
             // elements: g1
 10459  
             // token labels: 
 10460  
             // rule labels: retval, g1
 10461  
             // token list labels: 
 10462  
             // rule list labels: 
 10463  
             // wildcard labels: 
 10464  176
             retval.tree = root_0;
 10465  176
             RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 10466  176
             RewriteRuleSubtreeStream stream_g1=new RewriteRuleSubtreeStream(adaptor,"rule g1",g1!=null?g1.tree:null);
 10467  
 
 10468  176
             root_0 = (Object)adaptor.nil();
 10469  
             // 330:28: -> $g1
 10470  
             {
 10471  176
                 adaptor.addChild(root_0, stream_g1.nextTree());
 10472  
 
 10473  
             }
 10474  
 
 10475  
 
 10476  176
             retval.tree = root_0;
 10477  
 
 10478  
             }
 10479  
 
 10480  
 
 10481  
             // com\\googlecode\\sparkleg\\Sparql.g:330:35: ( ( UNION g2= groupGraphPattern ) -> ^( UNION $groupOrUnionGraphPattern $g2) )*
 10482  
             loop75:
 10483  
             do {
 10484  272
                 int alt75=2;
 10485  272
                 switch ( input.LA(1) ) {
 10486  
                 case UNION:
 10487  
                     {
 10488  96
                     alt75=1;
 10489  
                     }
 10490  
                     break;
 10491  
 
 10492  
                 }
 10493  
 
 10494  272
                 switch (alt75) {
 10495  
                     case 1 :
 10496  
                         // com\\googlecode\\sparkleg\\Sparql.g:330:36: ( UNION g2= groupGraphPattern )
 10497  
                         {
 10498  
                         // com\\googlecode\\sparkleg\\Sparql.g:330:36: ( UNION g2= groupGraphPattern )
 10499  
                         // com\\googlecode\\sparkleg\\Sparql.g:330:37: UNION g2= groupGraphPattern
 10500  
                         {
 10501  96
                         UNION237=(Token)match(input,UNION,FOLLOW_UNION_in_groupOrUnionGraphPattern2710);  
 10502  96
                         stream_UNION.add(UNION237);
 10503  
 
 10504  
 
 10505  96
                         pushFollow(FOLLOW_groupGraphPattern_in_groupOrUnionGraphPattern2714);
 10506  96
                         g2=groupGraphPattern();
 10507  
 
 10508  96
                         state._fsp--;
 10509  
 
 10510  96
                         stream_groupGraphPattern.add(g2.getTree());
 10511  
 
 10512  
                         }
 10513  
 
 10514  
 
 10515  
                         // AST REWRITE
 10516  
                         // elements: g2, UNION, groupOrUnionGraphPattern
 10517  
                         // token labels: 
 10518  
                         // rule labels: retval, g2
 10519  
                         // token list labels: 
 10520  
                         // rule list labels: 
 10521  
                         // wildcard labels: 
 10522  96
                         retval.tree = root_0;
 10523  96
                         RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 10524  96
                         RewriteRuleSubtreeStream stream_g2=new RewriteRuleSubtreeStream(adaptor,"rule g2",g2!=null?g2.tree:null);
 10525  
 
 10526  96
                         root_0 = (Object)adaptor.nil();
 10527  
                         // 330:65: -> ^( UNION $groupOrUnionGraphPattern $g2)
 10528  
                         {
 10529  
                             // com\\googlecode\\sparkleg\\Sparql.g:330:68: ^( UNION $groupOrUnionGraphPattern $g2)
 10530  
                             {
 10531  96
                             Object root_1 = (Object)adaptor.nil();
 10532  96
                             root_1 = (Object)adaptor.becomeRoot(
 10533  
                             stream_UNION.nextNode()
 10534  
                             , root_1);
 10535  
 
 10536  96
                             adaptor.addChild(root_1, stream_retval.nextTree());
 10537  
 
 10538  96
                             adaptor.addChild(root_1, stream_g2.nextTree());
 10539  
 
 10540  96
                             adaptor.addChild(root_0, root_1);
 10541  
                             }
 10542  
 
 10543  
                         }
 10544  
 
 10545  
 
 10546  96
                         retval.tree = root_0;
 10547  
 
 10548  
                         }
 10549  96
                         break;
 10550  
 
 10551  
                     default :
 10552  176
                         break loop75;
 10553  
                 }
 10554  96
             } while (true);
 10555  
 
 10556  
 
 10557  
             }
 10558  
 
 10559  176
             retval.stop = input.LT(-1);
 10560  
 
 10561  
 
 10562  176
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 10563  176
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 10564  
 
 10565  
         }
 10566  0
         catch (RecognitionException re) {
 10567  0
             reportError(re);
 10568  0
             recover(input,re);
 10569  0
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 10570  
 
 10571  
         }
 10572  
 
 10573  0
         finally {
 10574  
                 // do for sure before leaving
 10575  176
         }
 10576  176
         return retval;
 10577  
     }
 10578  
     // $ANTLR end "groupOrUnionGraphPattern"
 10579  
 
 10580  
 
 10581  584
     public static class filter_return extends ParserRuleReturnScope {
 10582  
         Object tree;
 10583  584
         public Object getTree() { return tree; }
 10584  
     };
 10585  
 
 10586  
 
 10587  
     // $ANTLR start "filter"
 10588  
     // com\\googlecode\\sparkleg\\Sparql.g:333:1: filter : FILTER constraint -> ^( FILTER constraint ) ;
 10589  
     public final SparqlParser.filter_return filter() throws RecognitionException {
 10590  584
         SparqlParser.filter_return retval = new SparqlParser.filter_return();
 10591  584
         retval.start = input.LT(1);
 10592  
 
 10593  
 
 10594  584
         Object root_0 = null;
 10595  
 
 10596  584
         Token FILTER238=null;
 10597  584
         SparqlParser.constraint_return constraint239 =null;
 10598  
 
 10599  
 
 10600  584
         Object FILTER238_tree=null;
 10601  584
         RewriteRuleTokenStream stream_FILTER=new RewriteRuleTokenStream(adaptor,"token FILTER");
 10602  584
         RewriteRuleSubtreeStream stream_constraint=new RewriteRuleSubtreeStream(adaptor,"rule constraint");
 10603  
         try {
 10604  
             // com\\googlecode\\sparkleg\\Sparql.g:334:5: ( FILTER constraint -> ^( FILTER constraint ) )
 10605  
             // com\\googlecode\\sparkleg\\Sparql.g:334:7: FILTER constraint
 10606  
             {
 10607  584
             FILTER238=(Token)match(input,FILTER,FOLLOW_FILTER_in_filter2746);  
 10608  584
             stream_FILTER.add(FILTER238);
 10609  
 
 10610  
 
 10611  584
             pushFollow(FOLLOW_constraint_in_filter2748);
 10612  584
             constraint239=constraint();
 10613  
 
 10614  584
             state._fsp--;
 10615  
 
 10616  584
             stream_constraint.add(constraint239.getTree());
 10617  
 
 10618  
             // AST REWRITE
 10619  
             // elements: constraint, FILTER
 10620  
             // token labels: 
 10621  
             // rule labels: retval
 10622  
             // token list labels: 
 10623  
             // rule list labels: 
 10624  
             // wildcard labels: 
 10625  584
             retval.tree = root_0;
 10626  584
             RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 10627  
 
 10628  584
             root_0 = (Object)adaptor.nil();
 10629  
             // 334:25: -> ^( FILTER constraint )
 10630  
             {
 10631  
                 // com\\googlecode\\sparkleg\\Sparql.g:334:28: ^( FILTER constraint )
 10632  
                 {
 10633  584
                 Object root_1 = (Object)adaptor.nil();
 10634  584
                 root_1 = (Object)adaptor.becomeRoot(
 10635  
                 stream_FILTER.nextNode()
 10636  
                 , root_1);
 10637  
 
 10638  584
                 adaptor.addChild(root_1, stream_constraint.nextTree());
 10639  
 
 10640  584
                 adaptor.addChild(root_0, root_1);
 10641  
                 }
 10642  
 
 10643  
             }
 10644  
 
 10645  
 
 10646  584
             retval.tree = root_0;
 10647  
 
 10648  
             }
 10649  
 
 10650  584
             retval.stop = input.LT(-1);
 10651  
 
 10652  
 
 10653  584
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 10654  584
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 10655  
 
 10656  
         }
 10657  0
         catch (RecognitionException re) {
 10658  0
             reportError(re);
 10659  0
             recover(input,re);
 10660  0
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 10661  
 
 10662  
         }
 10663  
 
 10664  0
         finally {
 10665  
                 // do for sure before leaving
 10666  584
         }
 10667  584
         return retval;
 10668  
     }
 10669  
     // $ANTLR end "filter"
 10670  
 
 10671  
 
 10672  612
     public static class constraint_return extends ParserRuleReturnScope {
 10673  
         Object tree;
 10674  612
         public Object getTree() { return tree; }
 10675  
     };
 10676  
 
 10677  
 
 10678  
     // $ANTLR start "constraint"
 10679  
     // com\\googlecode\\sparkleg\\Sparql.g:337:1: constraint : ( brackettedExpression | builtInCall | functionCall );
 10680  
     public final SparqlParser.constraint_return constraint() throws RecognitionException {
 10681  612
         SparqlParser.constraint_return retval = new SparqlParser.constraint_return();
 10682  612
         retval.start = input.LT(1);
 10683  
 
 10684  
 
 10685  612
         Object root_0 = null;
 10686  
 
 10687  612
         SparqlParser.brackettedExpression_return brackettedExpression240 =null;
 10688  
 
 10689  612
         SparqlParser.builtInCall_return builtInCall241 =null;
 10690  
 
 10691  612
         SparqlParser.functionCall_return functionCall242 =null;
 10692  
 
 10693  
 
 10694  
 
 10695  
         try {
 10696  
             // com\\googlecode\\sparkleg\\Sparql.g:338:5: ( brackettedExpression | builtInCall | functionCall )
 10697  612
             int alt76=3;
 10698  612
             switch ( input.LA(1) ) {
 10699  
             case OPEN_BRACE:
 10700  
                 {
 10701  446
                 alt76=1;
 10702  
                 }
 10703  446
                 break;
 10704  
             case ABS:
 10705  
             case BNODE:
 10706  
             case BOUND:
 10707  
             case CEIL:
 10708  
             case COALESCE:
 10709  
             case CONCAT:
 10710  
             case CONTAINS:
 10711  
             case DATATYPE:
 10712  
             case DAY:
 10713  
             case ENCODE_FOR_URI:
 10714  
             case EXISTS:
 10715  
             case FLOOR:
 10716  
             case HOURS:
 10717  
             case IF:
 10718  
             case IRI:
 10719  
             case ISBLANK:
 10720  
             case ISIRI:
 10721  
             case ISLITERAL:
 10722  
             case ISNUMERIC:
 10723  
             case ISURI:
 10724  
             case LANG:
 10725  
             case LANGMATCHES:
 10726  
             case LCASE:
 10727  
             case MD5:
 10728  
             case MINUTES:
 10729  
             case MONTH:
 10730  
             case NOT:
 10731  
             case NOW:
 10732  
             case RAND:
 10733  
             case REGEX:
 10734  
             case REPLACE:
 10735  
             case ROUND:
 10736  
             case SAMETERM:
 10737  
             case SECONDS:
 10738  
             case SHA1:
 10739  
             case SHA224:
 10740  
             case SHA256:
 10741  
             case SHA384:
 10742  
             case SHA512:
 10743  
             case STR:
 10744  
             case STRAFTER:
 10745  
             case STRBEFORE:
 10746  
             case STRDT:
 10747  
             case STRENDS:
 10748  
             case STRLANG:
 10749  
             case STRLEN:
 10750  
             case STRSTARTS:
 10751  
             case SUBSTR:
 10752  
             case TIMEZONE:
 10753  
             case TZ:
 10754  
             case UCASE:
 10755  
             case URI:
 10756  
             case YEAR:
 10757  
                 {
 10758  158
                 alt76=2;
 10759  
                 }
 10760  158
                 break;
 10761  
             case IRI_REF:
 10762  
             case PNAME_LN:
 10763  
             case PNAME_NS:
 10764  
                 {
 10765  8
                 alt76=3;
 10766  
                 }
 10767  8
                 break;
 10768  
             default:
 10769  0
                 NoViableAltException nvae =
 10770  
                     new NoViableAltException("", 76, 0, input);
 10771  
 
 10772  0
                 throw nvae;
 10773  
 
 10774  
             }
 10775  
 
 10776  612
             switch (alt76) {
 10777  
                 case 1 :
 10778  
                     // com\\googlecode\\sparkleg\\Sparql.g:338:7: brackettedExpression
 10779  
                     {
 10780  446
                     root_0 = (Object)adaptor.nil();
 10781  
 
 10782  
 
 10783  446
                     pushFollow(FOLLOW_brackettedExpression_in_constraint2773);
 10784  446
                     brackettedExpression240=brackettedExpression();
 10785  
 
 10786  446
                     state._fsp--;
 10787  
 
 10788  446
                     adaptor.addChild(root_0, brackettedExpression240.getTree());
 10789  
 
 10790  
                     }
 10791  446
                     break;
 10792  
                 case 2 :
 10793  
                     // com\\googlecode\\sparkleg\\Sparql.g:339:7: builtInCall
 10794  
                     {
 10795  158
                     root_0 = (Object)adaptor.nil();
 10796  
 
 10797  
 
 10798  158
                     pushFollow(FOLLOW_builtInCall_in_constraint2781);
 10799  158
                     builtInCall241=builtInCall();
 10800  
 
 10801  158
                     state._fsp--;
 10802  
 
 10803  158
                     adaptor.addChild(root_0, builtInCall241.getTree());
 10804  
 
 10805  
                     }
 10806  158
                     break;
 10807  
                 case 3 :
 10808  
                     // com\\googlecode\\sparkleg\\Sparql.g:340:7: functionCall
 10809  
                     {
 10810  8
                     root_0 = (Object)adaptor.nil();
 10811  
 
 10812  
 
 10813  8
                     pushFollow(FOLLOW_functionCall_in_constraint2789);
 10814  8
                     functionCall242=functionCall();
 10815  
 
 10816  8
                     state._fsp--;
 10817  
 
 10818  8
                     adaptor.addChild(root_0, functionCall242.getTree());
 10819  
 
 10820  
                     }
 10821  
                     break;
 10822  
 
 10823  
             }
 10824  612
             retval.stop = input.LT(-1);
 10825  
 
 10826  
 
 10827  612
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 10828  612
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 10829  
 
 10830  
         }
 10831  0
         catch (RecognitionException re) {
 10832  0
             reportError(re);
 10833  0
             recover(input,re);
 10834  0
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 10835  
 
 10836  
         }
 10837  
 
 10838  0
         finally {
 10839  
                 // do for sure before leaving
 10840  612
         }
 10841  612
         return retval;
 10842  
     }
 10843  
     // $ANTLR end "constraint"
 10844  
 
 10845  
 
 10846  8
     public static class functionCall_return extends ParserRuleReturnScope {
 10847  
         Object tree;
 10848  8
         public Object getTree() { return tree; }
 10849  
     };
 10850  
 
 10851  
 
 10852  
     // $ANTLR start "functionCall"
 10853  
     // com\\googlecode\\sparkleg\\Sparql.g:343:1: functionCall : iriRef argList -> ^( FUNCTION iriRef ^( ARG_LIST argList ) ) ;
 10854  
     public final SparqlParser.functionCall_return functionCall() throws RecognitionException {
 10855  8
         SparqlParser.functionCall_return retval = new SparqlParser.functionCall_return();
 10856  8
         retval.start = input.LT(1);
 10857  
 
 10858  
 
 10859  8
         Object root_0 = null;
 10860  
 
 10861  8
         SparqlParser.iriRef_return iriRef243 =null;
 10862  
 
 10863  8
         SparqlParser.argList_return argList244 =null;
 10864  
 
 10865  
 
 10866  8
         RewriteRuleSubtreeStream stream_argList=new RewriteRuleSubtreeStream(adaptor,"rule argList");
 10867  8
         RewriteRuleSubtreeStream stream_iriRef=new RewriteRuleSubtreeStream(adaptor,"rule iriRef");
 10868  
         try {
 10869  
             // com\\googlecode\\sparkleg\\Sparql.g:344:5: ( iriRef argList -> ^( FUNCTION iriRef ^( ARG_LIST argList ) ) )
 10870  
             // com\\googlecode\\sparkleg\\Sparql.g:344:7: iriRef argList
 10871  
             {
 10872  8
             pushFollow(FOLLOW_iriRef_in_functionCall2806);
 10873  8
             iriRef243=iriRef();
 10874  
 
 10875  8
             state._fsp--;
 10876  
 
 10877  8
             stream_iriRef.add(iriRef243.getTree());
 10878  
 
 10879  8
             pushFollow(FOLLOW_argList_in_functionCall2808);
 10880  8
             argList244=argList();
 10881  
 
 10882  8
             state._fsp--;
 10883  
 
 10884  8
             stream_argList.add(argList244.getTree());
 10885  
 
 10886  
             // AST REWRITE
 10887  
             // elements: iriRef, argList
 10888  
             // token labels: 
 10889  
             // rule labels: retval
 10890  
             // token list labels: 
 10891  
             // rule list labels: 
 10892  
             // wildcard labels: 
 10893  8
             retval.tree = root_0;
 10894  8
             RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 10895  
 
 10896  8
             root_0 = (Object)adaptor.nil();
 10897  
             // 344:22: -> ^( FUNCTION iriRef ^( ARG_LIST argList ) )
 10898  
             {
 10899  
                 // com\\googlecode\\sparkleg\\Sparql.g:344:25: ^( FUNCTION iriRef ^( ARG_LIST argList ) )
 10900  
                 {
 10901  8
                 Object root_1 = (Object)adaptor.nil();
 10902  8
                 root_1 = (Object)adaptor.becomeRoot(
 10903  
                 (Object)adaptor.create(FUNCTION, "FUNCTION")
 10904  
                 , root_1);
 10905  
 
 10906  8
                 adaptor.addChild(root_1, stream_iriRef.nextTree());
 10907  
 
 10908  
                 // com\\googlecode\\sparkleg\\Sparql.g:344:43: ^( ARG_LIST argList )
 10909  
                 {
 10910  8
                 Object root_2 = (Object)adaptor.nil();
 10911  8
                 root_2 = (Object)adaptor.becomeRoot(
 10912  
                 (Object)adaptor.create(ARG_LIST, "ARG_LIST")
 10913  
                 , root_2);
 10914  
 
 10915  8
                 adaptor.addChild(root_2, stream_argList.nextTree());
 10916  
 
 10917  8
                 adaptor.addChild(root_1, root_2);
 10918  
                 }
 10919  
 
 10920  8
                 adaptor.addChild(root_0, root_1);
 10921  
                 }
 10922  
 
 10923  
             }
 10924  
 
 10925  
 
 10926  8
             retval.tree = root_0;
 10927  
 
 10928  
             }
 10929  
 
 10930  8
             retval.stop = input.LT(-1);
 10931  
 
 10932  
 
 10933  8
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 10934  8
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 10935  
 
 10936  
         }
 10937  0
         catch (RecognitionException re) {
 10938  0
             reportError(re);
 10939  0
             recover(input,re);
 10940  0
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 10941  
 
 10942  
         }
 10943  
 
 10944  0
         finally {
 10945  
                 // do for sure before leaving
 10946  8
         }
 10947  8
         return retval;
 10948  
     }
 10949  
     // $ANTLR end "functionCall"
 10950  
 
 10951  
 
 10952  121
     public static class argList_return extends ParserRuleReturnScope {
 10953  
         Object tree;
 10954  121
         public Object getTree() { return tree; }
 10955  
     };
 10956  
 
 10957  
 
 10958  
     // $ANTLR start "argList"
 10959  
     // com\\googlecode\\sparkleg\\Sparql.g:347:1: argList : ( nil -> nil | OPEN_BRACE ( DISTINCT )? expression ( COMMA expression )* CLOSE_BRACE -> ( DISTINCT )? ( expression )* );
 10960  
     public final SparqlParser.argList_return argList() throws RecognitionException {
 10961  121
         SparqlParser.argList_return retval = new SparqlParser.argList_return();
 10962  121
         retval.start = input.LT(1);
 10963  
 
 10964  
 
 10965  121
         Object root_0 = null;
 10966  
 
 10967  121
         Token OPEN_BRACE246=null;
 10968  121
         Token DISTINCT247=null;
 10969  121
         Token COMMA249=null;
 10970  121
         Token CLOSE_BRACE251=null;
 10971  121
         SparqlParser.nil_return nil245 =null;
 10972  
 
 10973  121
         SparqlParser.expression_return expression248 =null;
 10974  
 
 10975  121
         SparqlParser.expression_return expression250 =null;
 10976  
 
 10977  
 
 10978  121
         Object OPEN_BRACE246_tree=null;
 10979  121
         Object DISTINCT247_tree=null;
 10980  121
         Object COMMA249_tree=null;
 10981  121
         Object CLOSE_BRACE251_tree=null;
 10982  121
         RewriteRuleTokenStream stream_CLOSE_BRACE=new RewriteRuleTokenStream(adaptor,"token CLOSE_BRACE");
 10983  121
         RewriteRuleTokenStream stream_COMMA=new RewriteRuleTokenStream(adaptor,"token COMMA");
 10984  121
         RewriteRuleTokenStream stream_OPEN_BRACE=new RewriteRuleTokenStream(adaptor,"token OPEN_BRACE");
 10985  121
         RewriteRuleTokenStream stream_DISTINCT=new RewriteRuleTokenStream(adaptor,"token DISTINCT");
 10986  121
         RewriteRuleSubtreeStream stream_expression=new RewriteRuleSubtreeStream(adaptor,"rule expression");
 10987  121
         RewriteRuleSubtreeStream stream_nil=new RewriteRuleSubtreeStream(adaptor,"rule nil");
 10988  
         try {
 10989  
             // com\\googlecode\\sparkleg\\Sparql.g:348:5: ( nil -> nil | OPEN_BRACE ( DISTINCT )? expression ( COMMA expression )* CLOSE_BRACE -> ( DISTINCT )? ( expression )* )
 10990  121
             int alt79=2;
 10991  121
             switch ( input.LA(1) ) {
 10992  
             case OPEN_BRACE:
 10993  
                 {
 10994  121
                 switch ( input.LA(2) ) {
 10995  
                 case CLOSE_BRACE:
 10996  
                     {
 10997  71
                     alt79=1;
 10998  
                     }
 10999  71
                     break;
 11000  
                 case ABS:
 11001  
                 case AVG:
 11002  
                 case BNODE:
 11003  
                 case BOUND:
 11004  
                 case CEIL:
 11005  
                 case COALESCE:
 11006  
                 case CONCAT:
 11007  
                 case CONTAINS:
 11008  
                 case COUNT:
 11009  
                 case DATATYPE:
 11010  
                 case DAY:
 11011  
                 case DECIMAL:
 11012  
                 case DECIMAL_NEGATIVE:
 11013  
                 case DECIMAL_POSITIVE:
 11014  
                 case DISTINCT:
 11015  
                 case DOUBLE:
 11016  
                 case DOUBLE_NEGATIVE:
 11017  
                 case DOUBLE_POSITIVE:
 11018  
                 case ENCODE_FOR_URI:
 11019  
                 case EXISTS:
 11020  
                 case FALSE:
 11021  
                 case FLOOR:
 11022  
                 case GROUP_CONCAT:
 11023  
                 case HOURS:
 11024  
                 case IF:
 11025  
                 case INTEGER:
 11026  
                 case INTEGER_NEGATIVE:
 11027  
                 case INTEGER_POSITIVE:
 11028  
                 case IRI:
 11029  
                 case IRI_REF:
 11030  
                 case ISBLANK:
 11031  
                 case ISIRI:
 11032  
                 case ISLITERAL:
 11033  
                 case ISNUMERIC:
 11034  
                 case ISURI:
 11035  
                 case LANG:
 11036  
                 case LANGMATCHES:
 11037  
                 case LCASE:
 11038  
                 case MAX:
 11039  
                 case MD5:
 11040  
                 case MIN:
 11041  
                 case MINUS:
 11042  
                 case MINUTES:
 11043  
                 case MONTH:
 11044  
                 case NEGATION:
 11045  
                 case NOT:
 11046  
                 case NOW:
 11047  
                 case OPEN_BRACE:
 11048  
                 case PLUS:
 11049  
                 case PNAME_LN:
 11050  
                 case PNAME_NS:
 11051  
                 case RAND:
 11052  
                 case REGEX:
 11053  
                 case REPLACE:
 11054  
                 case ROUND:
 11055  
                 case SAMETERM:
 11056  
                 case SAMPLE:
 11057  
                 case SECONDS:
 11058  
                 case SHA1:
 11059  
                 case SHA224:
 11060  
                 case SHA256:
 11061  
                 case SHA384:
 11062  
                 case SHA512:
 11063  
                 case STR:
 11064  
                 case STRAFTER:
 11065  
                 case STRBEFORE:
 11066  
                 case STRDT:
 11067  
                 case STRENDS:
 11068  
                 case STRING_LITERAL1:
 11069  
                 case STRING_LITERAL2:
 11070  
                 case STRING_LITERAL_LONG1:
 11071  
                 case STRING_LITERAL_LONG2:
 11072  
                 case STRLANG:
 11073  
                 case STRLEN:
 11074  
                 case STRSTARTS:
 11075  
                 case SUBSTR:
 11076  
                 case SUM:
 11077  
                 case TIMEZONE:
 11078  
                 case TRUE:
 11079  
                 case TZ:
 11080  
                 case UCASE:
 11081  
                 case URI:
 11082  
                 case VAR1:
 11083  
                 case VAR2:
 11084  
                 case YEAR:
 11085  
                     {
 11086  50
                     alt79=2;
 11087  
                     }
 11088  50
                     break;
 11089  
                 default:
 11090  0
                     NoViableAltException nvae =
 11091  
                         new NoViableAltException("", 79, 1, input);
 11092  
 
 11093  0
                     throw nvae;
 11094  
 
 11095  
                 }
 11096  
 
 11097  
                 }
 11098  121
                 break;
 11099  
             default:
 11100  0
                 NoViableAltException nvae =
 11101  
                     new NoViableAltException("", 79, 0, input);
 11102  
 
 11103  0
                 throw nvae;
 11104  
 
 11105  
             }
 11106  
 
 11107  121
             switch (alt79) {
 11108  
                 case 1 :
 11109  
                     // com\\googlecode\\sparkleg\\Sparql.g:348:7: nil
 11110  
                     {
 11111  71
                     pushFollow(FOLLOW_nil_in_argList2839);
 11112  71
                     nil245=nil();
 11113  
 
 11114  71
                     state._fsp--;
 11115  
 
 11116  71
                     stream_nil.add(nil245.getTree());
 11117  
 
 11118  
                     // AST REWRITE
 11119  
                     // elements: nil
 11120  
                     // token labels: 
 11121  
                     // rule labels: retval
 11122  
                     // token list labels: 
 11123  
                     // rule list labels: 
 11124  
                     // wildcard labels: 
 11125  71
                     retval.tree = root_0;
 11126  71
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 11127  
 
 11128  71
                     root_0 = (Object)adaptor.nil();
 11129  
                     // 348:11: -> nil
 11130  
                     {
 11131  71
                         adaptor.addChild(root_0, stream_nil.nextTree());
 11132  
 
 11133  
                     }
 11134  
 
 11135  
 
 11136  71
                     retval.tree = root_0;
 11137  
 
 11138  
                     }
 11139  71
                     break;
 11140  
                 case 2 :
 11141  
                     // com\\googlecode\\sparkleg\\Sparql.g:349:7: OPEN_BRACE ( DISTINCT )? expression ( COMMA expression )* CLOSE_BRACE
 11142  
                     {
 11143  50
                     OPEN_BRACE246=(Token)match(input,OPEN_BRACE,FOLLOW_OPEN_BRACE_in_argList2851);  
 11144  50
                     stream_OPEN_BRACE.add(OPEN_BRACE246);
 11145  
 
 11146  
 
 11147  
                     // com\\googlecode\\sparkleg\\Sparql.g:349:18: ( DISTINCT )?
 11148  50
                     int alt77=2;
 11149  50
                     switch ( input.LA(1) ) {
 11150  
                         case DISTINCT:
 11151  
                             {
 11152  0
                             alt77=1;
 11153  
                             }
 11154  
                             break;
 11155  
                     }
 11156  
 
 11157  50
                     switch (alt77) {
 11158  
                         case 1 :
 11159  
                             // com\\googlecode\\sparkleg\\Sparql.g:349:18: DISTINCT
 11160  
                             {
 11161  0
                             DISTINCT247=(Token)match(input,DISTINCT,FOLLOW_DISTINCT_in_argList2853);  
 11162  0
                             stream_DISTINCT.add(DISTINCT247);
 11163  
 
 11164  
 
 11165  
                             }
 11166  
                             break;
 11167  
 
 11168  
                     }
 11169  
 
 11170  
 
 11171  50
                     pushFollow(FOLLOW_expression_in_argList2856);
 11172  50
                     expression248=expression();
 11173  
 
 11174  50
                     state._fsp--;
 11175  
 
 11176  50
                     stream_expression.add(expression248.getTree());
 11177  
 
 11178  
                     // com\\googlecode\\sparkleg\\Sparql.g:349:39: ( COMMA expression )*
 11179  
                     loop78:
 11180  
                     do {
 11181  68
                         int alt78=2;
 11182  68
                         switch ( input.LA(1) ) {
 11183  
                         case COMMA:
 11184  
                             {
 11185  18
                             alt78=1;
 11186  
                             }
 11187  
                             break;
 11188  
 
 11189  
                         }
 11190  
 
 11191  68
                         switch (alt78) {
 11192  
                             case 1 :
 11193  
                                 // com\\googlecode\\sparkleg\\Sparql.g:349:40: COMMA expression
 11194  
                                 {
 11195  18
                                 COMMA249=(Token)match(input,COMMA,FOLLOW_COMMA_in_argList2859);  
 11196  18
                                 stream_COMMA.add(COMMA249);
 11197  
 
 11198  
 
 11199  18
                                 pushFollow(FOLLOW_expression_in_argList2861);
 11200  18
                                 expression250=expression();
 11201  
 
 11202  18
                                 state._fsp--;
 11203  
 
 11204  18
                                 stream_expression.add(expression250.getTree());
 11205  
 
 11206  
                                 }
 11207  18
                                 break;
 11208  
 
 11209  
                             default :
 11210  50
                                 break loop78;
 11211  
                         }
 11212  18
                     } while (true);
 11213  
 
 11214  
 
 11215  50
                     CLOSE_BRACE251=(Token)match(input,CLOSE_BRACE,FOLLOW_CLOSE_BRACE_in_argList2865);  
 11216  50
                     stream_CLOSE_BRACE.add(CLOSE_BRACE251);
 11217  
 
 11218  
 
 11219  
                     // AST REWRITE
 11220  
                     // elements: expression, DISTINCT
 11221  
                     // token labels: 
 11222  
                     // rule labels: retval
 11223  
                     // token list labels: 
 11224  
                     // rule list labels: 
 11225  
                     // wildcard labels: 
 11226  50
                     retval.tree = root_0;
 11227  50
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 11228  
 
 11229  50
                     root_0 = (Object)adaptor.nil();
 11230  
                     // 349:71: -> ( DISTINCT )? ( expression )*
 11231  
                     {
 11232  
                         // com\\googlecode\\sparkleg\\Sparql.g:349:74: ( DISTINCT )?
 11233  50
                         if ( stream_DISTINCT.hasNext() ) {
 11234  0
                             adaptor.addChild(root_0, 
 11235  
                             stream_DISTINCT.nextNode()
 11236  
                             );
 11237  
 
 11238  
                         }
 11239  50
                         stream_DISTINCT.reset();
 11240  
 
 11241  
                         // com\\googlecode\\sparkleg\\Sparql.g:349:84: ( expression )*
 11242  118
                         while ( stream_expression.hasNext() ) {
 11243  68
                             adaptor.addChild(root_0, stream_expression.nextTree());
 11244  
 
 11245  
                         }
 11246  50
                         stream_expression.reset();
 11247  
 
 11248  
                     }
 11249  
 
 11250  
 
 11251  50
                     retval.tree = root_0;
 11252  
 
 11253  
                     }
 11254  
                     break;
 11255  
 
 11256  
             }
 11257  121
             retval.stop = input.LT(-1);
 11258  
 
 11259  
 
 11260  121
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 11261  121
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 11262  
 
 11263  
         }
 11264  0
         catch (RecognitionException re) {
 11265  0
             reportError(re);
 11266  0
             recover(input,re);
 11267  0
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 11268  
 
 11269  
         }
 11270  
 
 11271  0
         finally {
 11272  
                 // do for sure before leaving
 11273  121
         }
 11274  121
         return retval;
 11275  
     }
 11276  
     // $ANTLR end "argList"
 11277  
 
 11278  
 
 11279  30
     public static class expressionList_return extends ParserRuleReturnScope {
 11280  
         Object tree;
 11281  30
         public Object getTree() { return tree; }
 11282  
     };
 11283  
 
 11284  
 
 11285  
     // $ANTLR start "expressionList"
 11286  
     // com\\googlecode\\sparkleg\\Sparql.g:352:1: expressionList : ( nil | OPEN_BRACE expression ( COMMA expression )* CLOSE_BRACE ) -> ^( EXPRESSION_LIST ( nil )* ( expression )* ) ;
 11287  
     public final SparqlParser.expressionList_return expressionList() throws RecognitionException {
 11288  30
         SparqlParser.expressionList_return retval = new SparqlParser.expressionList_return();
 11289  30
         retval.start = input.LT(1);
 11290  
 
 11291  
 
 11292  30
         Object root_0 = null;
 11293  
 
 11294  30
         Token OPEN_BRACE253=null;
 11295  30
         Token COMMA255=null;
 11296  30
         Token CLOSE_BRACE257=null;
 11297  30
         SparqlParser.nil_return nil252 =null;
 11298  
 
 11299  30
         SparqlParser.expression_return expression254 =null;
 11300  
 
 11301  30
         SparqlParser.expression_return expression256 =null;
 11302  
 
 11303  
 
 11304  30
         Object OPEN_BRACE253_tree=null;
 11305  30
         Object COMMA255_tree=null;
 11306  30
         Object CLOSE_BRACE257_tree=null;
 11307  30
         RewriteRuleTokenStream stream_CLOSE_BRACE=new RewriteRuleTokenStream(adaptor,"token CLOSE_BRACE");
 11308  30
         RewriteRuleTokenStream stream_COMMA=new RewriteRuleTokenStream(adaptor,"token COMMA");
 11309  30
         RewriteRuleTokenStream stream_OPEN_BRACE=new RewriteRuleTokenStream(adaptor,"token OPEN_BRACE");
 11310  30
         RewriteRuleSubtreeStream stream_expression=new RewriteRuleSubtreeStream(adaptor,"rule expression");
 11311  30
         RewriteRuleSubtreeStream stream_nil=new RewriteRuleSubtreeStream(adaptor,"rule nil");
 11312  
         try {
 11313  
             // com\\googlecode\\sparkleg\\Sparql.g:353:5: ( ( nil | OPEN_BRACE expression ( COMMA expression )* CLOSE_BRACE ) -> ^( EXPRESSION_LIST ( nil )* ( expression )* ) )
 11314  
             // com\\googlecode\\sparkleg\\Sparql.g:353:7: ( nil | OPEN_BRACE expression ( COMMA expression )* CLOSE_BRACE )
 11315  
             {
 11316  
             // com\\googlecode\\sparkleg\\Sparql.g:353:7: ( nil | OPEN_BRACE expression ( COMMA expression )* CLOSE_BRACE )
 11317  30
             int alt81=2;
 11318  30
             switch ( input.LA(1) ) {
 11319  
             case OPEN_BRACE:
 11320  
                 {
 11321  30
                 switch ( input.LA(2) ) {
 11322  
                 case CLOSE_BRACE:
 11323  
                     {
 11324  2
                     alt81=1;
 11325  
                     }
 11326  2
                     break;
 11327  
                 case ABS:
 11328  
                 case AVG:
 11329  
                 case BNODE:
 11330  
                 case BOUND:
 11331  
                 case CEIL:
 11332  
                 case COALESCE:
 11333  
                 case CONCAT:
 11334  
                 case CONTAINS:
 11335  
                 case COUNT:
 11336  
                 case DATATYPE:
 11337  
                 case DAY:
 11338  
                 case DECIMAL:
 11339  
                 case DECIMAL_NEGATIVE:
 11340  
                 case DECIMAL_POSITIVE:
 11341  
                 case DOUBLE:
 11342  
                 case DOUBLE_NEGATIVE:
 11343  
                 case DOUBLE_POSITIVE:
 11344  
                 case ENCODE_FOR_URI:
 11345  
                 case EXISTS:
 11346  
                 case FALSE:
 11347  
                 case FLOOR:
 11348  
                 case GROUP_CONCAT:
 11349  
                 case HOURS:
 11350  
                 case IF:
 11351  
                 case INTEGER:
 11352  
                 case INTEGER_NEGATIVE:
 11353  
                 case INTEGER_POSITIVE:
 11354  
                 case IRI:
 11355  
                 case IRI_REF:
 11356  
                 case ISBLANK:
 11357  
                 case ISIRI:
 11358  
                 case ISLITERAL:
 11359  
                 case ISNUMERIC:
 11360  
                 case ISURI:
 11361  
                 case LANG:
 11362  
                 case LANGMATCHES:
 11363  
                 case LCASE:
 11364  
                 case MAX:
 11365  
                 case MD5:
 11366  
                 case MIN:
 11367  
                 case MINUS:
 11368  
                 case MINUTES:
 11369  
                 case MONTH:
 11370  
                 case NEGATION:
 11371  
                 case NOT:
 11372  
                 case NOW:
 11373  
                 case OPEN_BRACE:
 11374  
                 case PLUS:
 11375  
                 case PNAME_LN:
 11376  
                 case PNAME_NS:
 11377  
                 case RAND:
 11378  
                 case REGEX:
 11379  
                 case REPLACE:
 11380  
                 case ROUND:
 11381  
                 case SAMETERM:
 11382  
                 case SAMPLE:
 11383  
                 case SECONDS:
 11384  
                 case SHA1:
 11385  
                 case SHA224:
 11386  
                 case SHA256:
 11387  
                 case SHA384:
 11388  
                 case SHA512:
 11389  
                 case STR:
 11390  
                 case STRAFTER:
 11391  
                 case STRBEFORE:
 11392  
                 case STRDT:
 11393  
                 case STRENDS:
 11394  
                 case STRING_LITERAL1:
 11395  
                 case STRING_LITERAL2:
 11396  
                 case STRING_LITERAL_LONG1:
 11397  
                 case STRING_LITERAL_LONG2:
 11398  
                 case STRLANG:
 11399  
                 case STRLEN:
 11400  
                 case STRSTARTS:
 11401  
                 case SUBSTR:
 11402  
                 case SUM:
 11403  
                 case TIMEZONE:
 11404  
                 case TRUE:
 11405  
                 case TZ:
 11406  
                 case UCASE:
 11407  
                 case URI:
 11408  
                 case VAR1:
 11409  
                 case VAR2:
 11410  
                 case YEAR:
 11411  
                     {
 11412  28
                     alt81=2;
 11413  
                     }
 11414  28
                     break;
 11415  
                 default:
 11416  0
                     NoViableAltException nvae =
 11417  
                         new NoViableAltException("", 81, 1, input);
 11418  
 
 11419  0
                     throw nvae;
 11420  
 
 11421  
                 }
 11422  
 
 11423  
                 }
 11424  30
                 break;
 11425  
             default:
 11426  0
                 NoViableAltException nvae =
 11427  
                     new NoViableAltException("", 81, 0, input);
 11428  
 
 11429  0
                 throw nvae;
 11430  
 
 11431  
             }
 11432  
 
 11433  30
             switch (alt81) {
 11434  
                 case 1 :
 11435  
                     // com\\googlecode\\sparkleg\\Sparql.g:353:8: nil
 11436  
                     {
 11437  2
                     pushFollow(FOLLOW_nil_in_expressionList2891);
 11438  2
                     nil252=nil();
 11439  
 
 11440  2
                     state._fsp--;
 11441  
 
 11442  2
                     stream_nil.add(nil252.getTree());
 11443  
 
 11444  
                     }
 11445  2
                     break;
 11446  
                 case 2 :
 11447  
                     // com\\googlecode\\sparkleg\\Sparql.g:353:14: OPEN_BRACE expression ( COMMA expression )* CLOSE_BRACE
 11448  
                     {
 11449  28
                     OPEN_BRACE253=(Token)match(input,OPEN_BRACE,FOLLOW_OPEN_BRACE_in_expressionList2895);  
 11450  28
                     stream_OPEN_BRACE.add(OPEN_BRACE253);
 11451  
 
 11452  
 
 11453  28
                     pushFollow(FOLLOW_expression_in_expressionList2897);
 11454  28
                     expression254=expression();
 11455  
 
 11456  28
                     state._fsp--;
 11457  
 
 11458  28
                     stream_expression.add(expression254.getTree());
 11459  
 
 11460  
                     // com\\googlecode\\sparkleg\\Sparql.g:353:36: ( COMMA expression )*
 11461  
                     loop80:
 11462  
                     do {
 11463  62
                         int alt80=2;
 11464  62
                         switch ( input.LA(1) ) {
 11465  
                         case COMMA:
 11466  
                             {
 11467  34
                             alt80=1;
 11468  
                             }
 11469  
                             break;
 11470  
 
 11471  
                         }
 11472  
 
 11473  62
                         switch (alt80) {
 11474  
                             case 1 :
 11475  
                                 // com\\googlecode\\sparkleg\\Sparql.g:353:37: COMMA expression
 11476  
                                 {
 11477  34
                                 COMMA255=(Token)match(input,COMMA,FOLLOW_COMMA_in_expressionList2900);  
 11478  34
                                 stream_COMMA.add(COMMA255);
 11479  
 
 11480  
 
 11481  34
                                 pushFollow(FOLLOW_expression_in_expressionList2902);
 11482  34
                                 expression256=expression();
 11483  
 
 11484  34
                                 state._fsp--;
 11485  
 
 11486  34
                                 stream_expression.add(expression256.getTree());
 11487  
 
 11488  
                                 }
 11489  34
                                 break;
 11490  
 
 11491  
                             default :
 11492  28
                                 break loop80;
 11493  
                         }
 11494  34
                     } while (true);
 11495  
 
 11496  
 
 11497  28
                     CLOSE_BRACE257=(Token)match(input,CLOSE_BRACE,FOLLOW_CLOSE_BRACE_in_expressionList2906);  
 11498  28
                     stream_CLOSE_BRACE.add(CLOSE_BRACE257);
 11499  
 
 11500  
 
 11501  
                     }
 11502  
                     break;
 11503  
 
 11504  
             }
 11505  
 
 11506  
 
 11507  
             // AST REWRITE
 11508  
             // elements: expression, nil
 11509  
             // token labels: 
 11510  
             // rule labels: retval
 11511  
             // token list labels: 
 11512  
             // rule list labels: 
 11513  
             // wildcard labels: 
 11514  30
             retval.tree = root_0;
 11515  30
             RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 11516  
 
 11517  30
             root_0 = (Object)adaptor.nil();
 11518  
             // 353:69: -> ^( EXPRESSION_LIST ( nil )* ( expression )* )
 11519  
             {
 11520  
                 // com\\googlecode\\sparkleg\\Sparql.g:353:72: ^( EXPRESSION_LIST ( nil )* ( expression )* )
 11521  
                 {
 11522  30
                 Object root_1 = (Object)adaptor.nil();
 11523  30
                 root_1 = (Object)adaptor.becomeRoot(
 11524  
                 (Object)adaptor.create(EXPRESSION_LIST, "EXPRESSION_LIST")
 11525  
                 , root_1);
 11526  
 
 11527  
                 // com\\googlecode\\sparkleg\\Sparql.g:353:90: ( nil )*
 11528  32
                 while ( stream_nil.hasNext() ) {
 11529  2
                     adaptor.addChild(root_1, stream_nil.nextTree());
 11530  
 
 11531  
                 }
 11532  30
                 stream_nil.reset();
 11533  
 
 11534  
                 // com\\googlecode\\sparkleg\\Sparql.g:353:95: ( expression )*
 11535  92
                 while ( stream_expression.hasNext() ) {
 11536  62
                     adaptor.addChild(root_1, stream_expression.nextTree());
 11537  
 
 11538  
                 }
 11539  30
                 stream_expression.reset();
 11540  
 
 11541  30
                 adaptor.addChild(root_0, root_1);
 11542  
                 }
 11543  
 
 11544  
             }
 11545  
 
 11546  
 
 11547  30
             retval.tree = root_0;
 11548  
 
 11549  
             }
 11550  
 
 11551  30
             retval.stop = input.LT(-1);
 11552  
 
 11553  
 
 11554  30
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 11555  30
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 11556  
 
 11557  
         }
 11558  0
         catch (RecognitionException re) {
 11559  0
             reportError(re);
 11560  0
             recover(input,re);
 11561  0
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 11562  
 
 11563  
         }
 11564  
 
 11565  0
         finally {
 11566  
                 // do for sure before leaving
 11567  30
         }
 11568  30
         return retval;
 11569  
     }
 11570  
     // $ANTLR end "expressionList"
 11571  
 
 11572  
 
 11573  54
     public static class constructTemplate_return extends ParserRuleReturnScope {
 11574  
         Object tree;
 11575  54
         public Object getTree() { return tree; }
 11576  
     };
 11577  
 
 11578  
 
 11579  
     // $ANTLR start "constructTemplate"
 11580  
     // com\\googlecode\\sparkleg\\Sparql.g:356:1: constructTemplate : OPEN_CURLY_BRACE ( constructTriples )? CLOSE_CURLY_BRACE -> ^( CONSTRUCT_TRIPLES ( constructTriples )? ) ;
 11581  
     public final SparqlParser.constructTemplate_return constructTemplate() throws RecognitionException {
 11582  54
         SparqlParser.constructTemplate_return retval = new SparqlParser.constructTemplate_return();
 11583  54
         retval.start = input.LT(1);
 11584  
 
 11585  
 
 11586  54
         Object root_0 = null;
 11587  
 
 11588  54
         Token OPEN_CURLY_BRACE258=null;
 11589  54
         Token CLOSE_CURLY_BRACE260=null;
 11590  54
         SparqlParser.constructTriples_return constructTriples259 =null;
 11591  
 
 11592  
 
 11593  54
         Object OPEN_CURLY_BRACE258_tree=null;
 11594  54
         Object CLOSE_CURLY_BRACE260_tree=null;
 11595  54
         RewriteRuleTokenStream stream_OPEN_CURLY_BRACE=new RewriteRuleTokenStream(adaptor,"token OPEN_CURLY_BRACE");
 11596  54
         RewriteRuleTokenStream stream_CLOSE_CURLY_BRACE=new RewriteRuleTokenStream(adaptor,"token CLOSE_CURLY_BRACE");
 11597  54
         RewriteRuleSubtreeStream stream_constructTriples=new RewriteRuleSubtreeStream(adaptor,"rule constructTriples");
 11598  
         try {
 11599  
             // com\\googlecode\\sparkleg\\Sparql.g:357:5: ( OPEN_CURLY_BRACE ( constructTriples )? CLOSE_CURLY_BRACE -> ^( CONSTRUCT_TRIPLES ( constructTriples )? ) )
 11600  
             // com\\googlecode\\sparkleg\\Sparql.g:357:7: OPEN_CURLY_BRACE ( constructTriples )? CLOSE_CURLY_BRACE
 11601  
             {
 11602  54
             OPEN_CURLY_BRACE258=(Token)match(input,OPEN_CURLY_BRACE,FOLLOW_OPEN_CURLY_BRACE_in_constructTemplate2937);  
 11603  54
             stream_OPEN_CURLY_BRACE.add(OPEN_CURLY_BRACE258);
 11604  
 
 11605  
 
 11606  
             // com\\googlecode\\sparkleg\\Sparql.g:357:24: ( constructTriples )?
 11607  54
             int alt82=2;
 11608  54
             switch ( input.LA(1) ) {
 11609  
                 case BLANK_NODE_LABEL:
 11610  
                 case DECIMAL:
 11611  
                 case DECIMAL_NEGATIVE:
 11612  
                 case DECIMAL_POSITIVE:
 11613  
                 case DOUBLE:
 11614  
                 case DOUBLE_NEGATIVE:
 11615  
                 case DOUBLE_POSITIVE:
 11616  
                 case FALSE:
 11617  
                 case INTEGER:
 11618  
                 case INTEGER_NEGATIVE:
 11619  
                 case INTEGER_POSITIVE:
 11620  
                 case IRI_REF:
 11621  
                 case OPEN_BRACE:
 11622  
                 case OPEN_SQUARE_BRACKET:
 11623  
                 case PNAME_LN:
 11624  
                 case PNAME_NS:
 11625  
                 case STRING_LITERAL1:
 11626  
                 case STRING_LITERAL2:
 11627  
                 case STRING_LITERAL_LONG1:
 11628  
                 case STRING_LITERAL_LONG2:
 11629  
                 case TRUE:
 11630  
                 case VAR1:
 11631  
                 case VAR2:
 11632  
                     {
 11633  52
                     alt82=1;
 11634  
                     }
 11635  
                     break;
 11636  
             }
 11637  
 
 11638  54
             switch (alt82) {
 11639  
                 case 1 :
 11640  
                     // com\\googlecode\\sparkleg\\Sparql.g:357:24: constructTriples
 11641  
                     {
 11642  52
                     pushFollow(FOLLOW_constructTriples_in_constructTemplate2939);
 11643  52
                     constructTriples259=constructTriples();
 11644  
 
 11645  52
                     state._fsp--;
 11646  
 
 11647  52
                     stream_constructTriples.add(constructTriples259.getTree());
 11648  
 
 11649  
                     }
 11650  
                     break;
 11651  
 
 11652  
             }
 11653  
 
 11654  
 
 11655  54
             CLOSE_CURLY_BRACE260=(Token)match(input,CLOSE_CURLY_BRACE,FOLLOW_CLOSE_CURLY_BRACE_in_constructTemplate2942);  
 11656  54
             stream_CLOSE_CURLY_BRACE.add(CLOSE_CURLY_BRACE260);
 11657  
 
 11658  
 
 11659  
             // AST REWRITE
 11660  
             // elements: constructTriples
 11661  
             // token labels: 
 11662  
             // rule labels: retval
 11663  
             // token list labels: 
 11664  
             // rule list labels: 
 11665  
             // wildcard labels: 
 11666  54
             retval.tree = root_0;
 11667  54
             RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 11668  
 
 11669  54
             root_0 = (Object)adaptor.nil();
 11670  
             // 357:60: -> ^( CONSTRUCT_TRIPLES ( constructTriples )? )
 11671  
             {
 11672  
                 // com\\googlecode\\sparkleg\\Sparql.g:357:63: ^( CONSTRUCT_TRIPLES ( constructTriples )? )
 11673  
                 {
 11674  54
                 Object root_1 = (Object)adaptor.nil();
 11675  54
                 root_1 = (Object)adaptor.becomeRoot(
 11676  
                 (Object)adaptor.create(CONSTRUCT_TRIPLES, "CONSTRUCT_TRIPLES")
 11677  
                 , root_1);
 11678  
 
 11679  
                 // com\\googlecode\\sparkleg\\Sparql.g:357:83: ( constructTriples )?
 11680  54
                 if ( stream_constructTriples.hasNext() ) {
 11681  52
                     adaptor.addChild(root_1, stream_constructTriples.nextTree());
 11682  
 
 11683  
                 }
 11684  54
                 stream_constructTriples.reset();
 11685  
 
 11686  54
                 adaptor.addChild(root_0, root_1);
 11687  
                 }
 11688  
 
 11689  
             }
 11690  
 
 11691  
 
 11692  54
             retval.tree = root_0;
 11693  
 
 11694  
             }
 11695  
 
 11696  54
             retval.stop = input.LT(-1);
 11697  
 
 11698  
 
 11699  54
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 11700  54
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 11701  
 
 11702  
         }
 11703  0
         catch (RecognitionException re) {
 11704  0
             reportError(re);
 11705  0
             recover(input,re);
 11706  0
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 11707  
 
 11708  
         }
 11709  
 
 11710  0
         finally {
 11711  
                 // do for sure before leaving
 11712  54
         }
 11713  54
         return retval;
 11714  
     }
 11715  
     // $ANTLR end "constructTemplate"
 11716  
 
 11717  
 
 11718  52
     public static class constructTriples_return extends ParserRuleReturnScope {
 11719  
         Object tree;
 11720  52
         public Object getTree() { return tree; }
 11721  
     };
 11722  
 
 11723  
 
 11724  
     // $ANTLR start "constructTriples"
 11725  
     // com\\googlecode\\sparkleg\\Sparql.g:360:1: constructTriples : triplesSameSubject ( DOT triplesSameSubject )* ( DOT )? -> ( triplesSameSubject )+ ;
 11726  
     public final SparqlParser.constructTriples_return constructTriples() throws RecognitionException {
 11727  52
         SparqlParser.constructTriples_return retval = new SparqlParser.constructTriples_return();
 11728  52
         retval.start = input.LT(1);
 11729  
 
 11730  
 
 11731  52
         Object root_0 = null;
 11732  
 
 11733  52
         Token DOT262=null;
 11734  52
         Token DOT264=null;
 11735  52
         SparqlParser.triplesSameSubject_return triplesSameSubject261 =null;
 11736  
 
 11737  52
         SparqlParser.triplesSameSubject_return triplesSameSubject263 =null;
 11738  
 
 11739  
 
 11740  52
         Object DOT262_tree=null;
 11741  52
         Object DOT264_tree=null;
 11742  52
         RewriteRuleTokenStream stream_DOT=new RewriteRuleTokenStream(adaptor,"token DOT");
 11743  52
         RewriteRuleSubtreeStream stream_triplesSameSubject=new RewriteRuleSubtreeStream(adaptor,"rule triplesSameSubject");
 11744  
         try {
 11745  
             // com\\googlecode\\sparkleg\\Sparql.g:361:5: ( triplesSameSubject ( DOT triplesSameSubject )* ( DOT )? -> ( triplesSameSubject )+ )
 11746  
             // com\\googlecode\\sparkleg\\Sparql.g:361:7: triplesSameSubject ( DOT triplesSameSubject )* ( DOT )?
 11747  
             {
 11748  52
             pushFollow(FOLLOW_triplesSameSubject_in_constructTriples2968);
 11749  52
             triplesSameSubject261=triplesSameSubject();
 11750  
 
 11751  52
             state._fsp--;
 11752  
 
 11753  52
             stream_triplesSameSubject.add(triplesSameSubject261.getTree());
 11754  
 
 11755  
             // com\\googlecode\\sparkleg\\Sparql.g:361:26: ( DOT triplesSameSubject )*
 11756  
             loop83:
 11757  
             do {
 11758  68
                 int alt83=2;
 11759  68
                 switch ( input.LA(1) ) {
 11760  
                 case DOT:
 11761  
                     {
 11762  48
                     switch ( input.LA(2) ) {
 11763  
                     case BLANK_NODE_LABEL:
 11764  
                     case DECIMAL:
 11765  
                     case DECIMAL_NEGATIVE:
 11766  
                     case DECIMAL_POSITIVE:
 11767  
                     case DOUBLE:
 11768  
                     case DOUBLE_NEGATIVE:
 11769  
                     case DOUBLE_POSITIVE:
 11770  
                     case FALSE:
 11771  
                     case INTEGER:
 11772  
                     case INTEGER_NEGATIVE:
 11773  
                     case INTEGER_POSITIVE:
 11774  
                     case IRI_REF:
 11775  
                     case OPEN_BRACE:
 11776  
                     case OPEN_SQUARE_BRACKET:
 11777  
                     case PNAME_LN:
 11778  
                     case PNAME_NS:
 11779  
                     case STRING_LITERAL1:
 11780  
                     case STRING_LITERAL2:
 11781  
                     case STRING_LITERAL_LONG1:
 11782  
                     case STRING_LITERAL_LONG2:
 11783  
                     case TRUE:
 11784  
                     case VAR1:
 11785  
                     case VAR2:
 11786  
                         {
 11787  16
                         alt83=1;
 11788  
                         }
 11789  
                         break;
 11790  
 
 11791  
                     }
 11792  
 
 11793  
                     }
 11794  
                     break;
 11795  
 
 11796  
                 }
 11797  
 
 11798  68
                 switch (alt83) {
 11799  
                     case 1 :
 11800  
                         // com\\googlecode\\sparkleg\\Sparql.g:361:27: DOT triplesSameSubject
 11801  
                         {
 11802  16
                         DOT262=(Token)match(input,DOT,FOLLOW_DOT_in_constructTriples2971);  
 11803  16
                         stream_DOT.add(DOT262);
 11804  
 
 11805  
 
 11806  16
                         pushFollow(FOLLOW_triplesSameSubject_in_constructTriples2973);
 11807  16
                         triplesSameSubject263=triplesSameSubject();
 11808  
 
 11809  16
                         state._fsp--;
 11810  
 
 11811  16
                         stream_triplesSameSubject.add(triplesSameSubject263.getTree());
 11812  
 
 11813  
                         }
 11814  16
                         break;
 11815  
 
 11816  
                     default :
 11817  52
                         break loop83;
 11818  
                 }
 11819  16
             } while (true);
 11820  
 
 11821  
 
 11822  
             // com\\googlecode\\sparkleg\\Sparql.g:361:52: ( DOT )?
 11823  52
             int alt84=2;
 11824  52
             switch ( input.LA(1) ) {
 11825  
                 case DOT:
 11826  
                     {
 11827  32
                     alt84=1;
 11828  
                     }
 11829  
                     break;
 11830  
             }
 11831  
 
 11832  52
             switch (alt84) {
 11833  
                 case 1 :
 11834  
                     // com\\googlecode\\sparkleg\\Sparql.g:361:52: DOT
 11835  
                     {
 11836  32
                     DOT264=(Token)match(input,DOT,FOLLOW_DOT_in_constructTriples2977);  
 11837  32
                     stream_DOT.add(DOT264);
 11838  
 
 11839  
 
 11840  
                     }
 11841  
                     break;
 11842  
 
 11843  
             }
 11844  
 
 11845  
 
 11846  
             // AST REWRITE
 11847  
             // elements: triplesSameSubject
 11848  
             // token labels: 
 11849  
             // rule labels: retval
 11850  
             // token list labels: 
 11851  
             // rule list labels: 
 11852  
             // wildcard labels: 
 11853  52
             retval.tree = root_0;
 11854  52
             RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 11855  
 
 11856  52
             root_0 = (Object)adaptor.nil();
 11857  
             // 361:57: -> ( triplesSameSubject )+
 11858  
             {
 11859  52
                 if ( !(stream_triplesSameSubject.hasNext()) ) {
 11860  0
                     throw new RewriteEarlyExitException();
 11861  
                 }
 11862  120
                 while ( stream_triplesSameSubject.hasNext() ) {
 11863  68
                     adaptor.addChild(root_0, stream_triplesSameSubject.nextTree());
 11864  
 
 11865  
                 }
 11866  52
                 stream_triplesSameSubject.reset();
 11867  
 
 11868  
             }
 11869  
 
 11870  
 
 11871  52
             retval.tree = root_0;
 11872  
 
 11873  
             }
 11874  
 
 11875  52
             retval.stop = input.LT(-1);
 11876  
 
 11877  
 
 11878  52
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 11879  52
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 11880  
 
 11881  
         }
 11882  0
         catch (RecognitionException re) {
 11883  0
             reportError(re);
 11884  0
             recover(input,re);
 11885  0
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 11886  
 
 11887  
         }
 11888  
 
 11889  0
         finally {
 11890  
                 // do for sure before leaving
 11891  52
         }
 11892  52
         return retval;
 11893  
     }
 11894  
     // $ANTLR end "constructTriples"
 11895  
 
 11896  
 
 11897  194
     public static class triplesSameSubject_return extends ParserRuleReturnScope {
 11898  
         Object tree;
 11899  194
         public Object getTree() { return tree; }
 11900  
     };
 11901  
 
 11902  
 
 11903  
     // $ANTLR start "triplesSameSubject"
 11904  
     // com\\googlecode\\sparkleg\\Sparql.g:364:1: triplesSameSubject : ( varOrTerm ( propertyListNotEmpty )? -> ^( TRIPLES_SAME_SUBJECT ^( SUBJECT varOrTerm ) ( propertyListNotEmpty )? ) | triplesNode ( propertyListNotEmpty )? -> ^( TRIPLES_SAME_SUBJECT triplesNode ( propertyListNotEmpty )? ) );
 11905  
     public final SparqlParser.triplesSameSubject_return triplesSameSubject() throws RecognitionException {
 11906  194
         SparqlParser.triplesSameSubject_return retval = new SparqlParser.triplesSameSubject_return();
 11907  194
         retval.start = input.LT(1);
 11908  
 
 11909  
 
 11910  194
         Object root_0 = null;
 11911  
 
 11912  194
         SparqlParser.varOrTerm_return varOrTerm265 =null;
 11913  
 
 11914  194
         SparqlParser.propertyListNotEmpty_return propertyListNotEmpty266 =null;
 11915  
 
 11916  194
         SparqlParser.triplesNode_return triplesNode267 =null;
 11917  
 
 11918  194
         SparqlParser.propertyListNotEmpty_return propertyListNotEmpty268 =null;
 11919  
 
 11920  
 
 11921  194
         RewriteRuleSubtreeStream stream_varOrTerm=new RewriteRuleSubtreeStream(adaptor,"rule varOrTerm");
 11922  194
         RewriteRuleSubtreeStream stream_propertyListNotEmpty=new RewriteRuleSubtreeStream(adaptor,"rule propertyListNotEmpty");
 11923  194
         RewriteRuleSubtreeStream stream_triplesNode=new RewriteRuleSubtreeStream(adaptor,"rule triplesNode");
 11924  
         try {
 11925  
             // com\\googlecode\\sparkleg\\Sparql.g:365:5: ( varOrTerm ( propertyListNotEmpty )? -> ^( TRIPLES_SAME_SUBJECT ^( SUBJECT varOrTerm ) ( propertyListNotEmpty )? ) | triplesNode ( propertyListNotEmpty )? -> ^( TRIPLES_SAME_SUBJECT triplesNode ( propertyListNotEmpty )? ) )
 11926  194
             int alt87=2;
 11927  194
             switch ( input.LA(1) ) {
 11928  
             case BLANK_NODE_LABEL:
 11929  
             case DECIMAL:
 11930  
             case DECIMAL_NEGATIVE:
 11931  
             case DECIMAL_POSITIVE:
 11932  
             case DOUBLE:
 11933  
             case DOUBLE_NEGATIVE:
 11934  
             case DOUBLE_POSITIVE:
 11935  
             case FALSE:
 11936  
             case INTEGER:
 11937  
             case INTEGER_NEGATIVE:
 11938  
             case INTEGER_POSITIVE:
 11939  
             case IRI_REF:
 11940  
             case PNAME_LN:
 11941  
             case PNAME_NS:
 11942  
             case STRING_LITERAL1:
 11943  
             case STRING_LITERAL2:
 11944  
             case STRING_LITERAL_LONG1:
 11945  
             case STRING_LITERAL_LONG2:
 11946  
             case TRUE:
 11947  
             case VAR1:
 11948  
             case VAR2:
 11949  
                 {
 11950  182
                 alt87=1;
 11951  
                 }
 11952  182
                 break;
 11953  
             case OPEN_SQUARE_BRACKET:
 11954  
                 {
 11955  12
                 switch ( input.LA(2) ) {
 11956  
                 case CLOSE_SQUARE_BRACKET:
 11957  
                     {
 11958  10
                     alt87=1;
 11959  
                     }
 11960  10
                     break;
 11961  
                 case A:
 11962  
                 case INVERSE:
 11963  
                 case IRI_REF:
 11964  
                 case NEGATION:
 11965  
                 case OPEN_BRACE:
 11966  
                 case PNAME_LN:
 11967  
                 case PNAME_NS:
 11968  
                 case VAR1:
 11969  
                 case VAR2:
 11970  
                     {
 11971  2
                     alt87=2;
 11972  
                     }
 11973  2
                     break;
 11974  
                 default:
 11975  0
                     NoViableAltException nvae =
 11976  
                         new NoViableAltException("", 87, 2, input);
 11977  
 
 11978  0
                     throw nvae;
 11979  
 
 11980  
                 }
 11981  
 
 11982  
                 }
 11983  12
                 break;
 11984  
             case OPEN_BRACE:
 11985  
                 {
 11986  0
                 switch ( input.LA(2) ) {
 11987  
                 case CLOSE_BRACE:
 11988  
                     {
 11989  0
                     alt87=1;
 11990  
                     }
 11991  0
                     break;
 11992  
                 case BLANK_NODE_LABEL:
 11993  
                 case DECIMAL:
 11994  
                 case DECIMAL_NEGATIVE:
 11995  
                 case DECIMAL_POSITIVE:
 11996  
                 case DOUBLE:
 11997  
                 case DOUBLE_NEGATIVE:
 11998  
                 case DOUBLE_POSITIVE:
 11999  
                 case FALSE:
 12000  
                 case INTEGER:
 12001  
                 case INTEGER_NEGATIVE:
 12002  
                 case INTEGER_POSITIVE:
 12003  
                 case IRI_REF:
 12004  
                 case OPEN_BRACE:
 12005  
                 case OPEN_SQUARE_BRACKET:
 12006  
                 case PNAME_LN:
 12007  
                 case PNAME_NS:
 12008  
                 case STRING_LITERAL1:
 12009  
                 case STRING_LITERAL2:
 12010  
                 case STRING_LITERAL_LONG1:
 12011  
                 case STRING_LITERAL_LONG2:
 12012  
                 case TRUE:
 12013  
                 case VAR1:
 12014  
                 case VAR2:
 12015  
                     {
 12016  0
                     alt87=2;
 12017  
                     }
 12018  0
                     break;
 12019  
                 default:
 12020  0
                     NoViableAltException nvae =
 12021  
                         new NoViableAltException("", 87, 3, input);
 12022  
 
 12023  0
                     throw nvae;
 12024  
 
 12025  
                 }
 12026  
 
 12027  
                 }
 12028  0
                 break;
 12029  
             default:
 12030  0
                 NoViableAltException nvae =
 12031  
                     new NoViableAltException("", 87, 0, input);
 12032  
 
 12033  0
                 throw nvae;
 12034  
 
 12035  
             }
 12036  
 
 12037  194
             switch (alt87) {
 12038  
                 case 1 :
 12039  
                     // com\\googlecode\\sparkleg\\Sparql.g:365:7: varOrTerm ( propertyListNotEmpty )?
 12040  
                     {
 12041  192
                     pushFollow(FOLLOW_varOrTerm_in_triplesSameSubject3000);
 12042  192
                     varOrTerm265=varOrTerm();
 12043  
 
 12044  192
                     state._fsp--;
 12045  
 
 12046  192
                     stream_varOrTerm.add(varOrTerm265.getTree());
 12047  
 
 12048  
                     // com\\googlecode\\sparkleg\\Sparql.g:365:17: ( propertyListNotEmpty )?
 12049  192
                     int alt85=2;
 12050  192
                     switch ( input.LA(1) ) {
 12051  
                         case A:
 12052  
                         case INVERSE:
 12053  
                         case IRI_REF:
 12054  
                         case NEGATION:
 12055  
                         case OPEN_BRACE:
 12056  
                         case PNAME_LN:
 12057  
                         case PNAME_NS:
 12058  
                         case VAR1:
 12059  
                         case VAR2:
 12060  
                             {
 12061  192
                             alt85=1;
 12062  
                             }
 12063  
                             break;
 12064  
                     }
 12065  
 
 12066  192
                     switch (alt85) {
 12067  
                         case 1 :
 12068  
                             // com\\googlecode\\sparkleg\\Sparql.g:365:17: propertyListNotEmpty
 12069  
                             {
 12070  192
                             pushFollow(FOLLOW_propertyListNotEmpty_in_triplesSameSubject3002);
 12071  192
                             propertyListNotEmpty266=propertyListNotEmpty();
 12072  
 
 12073  192
                             state._fsp--;
 12074  
 
 12075  192
                             stream_propertyListNotEmpty.add(propertyListNotEmpty266.getTree());
 12076  
 
 12077  
                             }
 12078  
                             break;
 12079  
 
 12080  
                     }
 12081  
 
 12082  
 
 12083  
                     // AST REWRITE
 12084  
                     // elements: propertyListNotEmpty, varOrTerm
 12085  
                     // token labels: 
 12086  
                     // rule labels: retval
 12087  
                     // token list labels: 
 12088  
                     // rule list labels: 
 12089  
                     // wildcard labels: 
 12090  192
                     retval.tree = root_0;
 12091  192
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 12092  
 
 12093  192
                     root_0 = (Object)adaptor.nil();
 12094  
                     // 365:39: -> ^( TRIPLES_SAME_SUBJECT ^( SUBJECT varOrTerm ) ( propertyListNotEmpty )? )
 12095  
                     {
 12096  
                         // com\\googlecode\\sparkleg\\Sparql.g:365:42: ^( TRIPLES_SAME_SUBJECT ^( SUBJECT varOrTerm ) ( propertyListNotEmpty )? )
 12097  
                         {
 12098  192
                         Object root_1 = (Object)adaptor.nil();
 12099  192
                         root_1 = (Object)adaptor.becomeRoot(
 12100  
                         (Object)adaptor.create(TRIPLES_SAME_SUBJECT, "TRIPLES_SAME_SUBJECT")
 12101  
                         , root_1);
 12102  
 
 12103  
                         // com\\googlecode\\sparkleg\\Sparql.g:365:65: ^( SUBJECT varOrTerm )
 12104  
                         {
 12105  192
                         Object root_2 = (Object)adaptor.nil();
 12106  192
                         root_2 = (Object)adaptor.becomeRoot(
 12107  
                         (Object)adaptor.create(SUBJECT, "SUBJECT")
 12108  
                         , root_2);
 12109  
 
 12110  192
                         adaptor.addChild(root_2, stream_varOrTerm.nextTree());
 12111  
 
 12112  192
                         adaptor.addChild(root_1, root_2);
 12113  
                         }
 12114  
 
 12115  
                         // com\\googlecode\\sparkleg\\Sparql.g:365:86: ( propertyListNotEmpty )?
 12116  192
                         if ( stream_propertyListNotEmpty.hasNext() ) {
 12117  192
                             adaptor.addChild(root_1, stream_propertyListNotEmpty.nextTree());
 12118  
 
 12119  
                         }
 12120  192
                         stream_propertyListNotEmpty.reset();
 12121  
 
 12122  192
                         adaptor.addChild(root_0, root_1);
 12123  
                         }
 12124  
 
 12125  
                     }
 12126  
 
 12127  
 
 12128  192
                     retval.tree = root_0;
 12129  
 
 12130  
                     }
 12131  192
                     break;
 12132  
                 case 2 :
 12133  
                     // com\\googlecode\\sparkleg\\Sparql.g:366:7: triplesNode ( propertyListNotEmpty )?
 12134  
                     {
 12135  2
                     pushFollow(FOLLOW_triplesNode_in_triplesSameSubject3026);
 12136  2
                     triplesNode267=triplesNode();
 12137  
 
 12138  2
                     state._fsp--;
 12139  
 
 12140  2
                     stream_triplesNode.add(triplesNode267.getTree());
 12141  
 
 12142  
                     // com\\googlecode\\sparkleg\\Sparql.g:366:19: ( propertyListNotEmpty )?
 12143  2
                     int alt86=2;
 12144  2
                     switch ( input.LA(1) ) {
 12145  
                         case A:
 12146  
                         case INVERSE:
 12147  
                         case IRI_REF:
 12148  
                         case NEGATION:
 12149  
                         case OPEN_BRACE:
 12150  
                         case PNAME_LN:
 12151  
                         case PNAME_NS:
 12152  
                         case VAR1:
 12153  
                         case VAR2:
 12154  
                             {
 12155  0
                             alt86=1;
 12156  
                             }
 12157  
                             break;
 12158  
                     }
 12159  
 
 12160  2
                     switch (alt86) {
 12161  
                         case 1 :
 12162  
                             // com\\googlecode\\sparkleg\\Sparql.g:366:19: propertyListNotEmpty
 12163  
                             {
 12164  0
                             pushFollow(FOLLOW_propertyListNotEmpty_in_triplesSameSubject3028);
 12165  0
                             propertyListNotEmpty268=propertyListNotEmpty();
 12166  
 
 12167  0
                             state._fsp--;
 12168  
 
 12169  0
                             stream_propertyListNotEmpty.add(propertyListNotEmpty268.getTree());
 12170  
 
 12171  
                             }
 12172  
                             break;
 12173  
 
 12174  
                     }
 12175  
 
 12176  
 
 12177  
                     // AST REWRITE
 12178  
                     // elements: propertyListNotEmpty, triplesNode
 12179  
                     // token labels: 
 12180  
                     // rule labels: retval
 12181  
                     // token list labels: 
 12182  
                     // rule list labels: 
 12183  
                     // wildcard labels: 
 12184  2
                     retval.tree = root_0;
 12185  2
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 12186  
 
 12187  2
                     root_0 = (Object)adaptor.nil();
 12188  
                     // 366:41: -> ^( TRIPLES_SAME_SUBJECT triplesNode ( propertyListNotEmpty )? )
 12189  
                     {
 12190  
                         // com\\googlecode\\sparkleg\\Sparql.g:366:44: ^( TRIPLES_SAME_SUBJECT triplesNode ( propertyListNotEmpty )? )
 12191  
                         {
 12192  2
                         Object root_1 = (Object)adaptor.nil();
 12193  2
                         root_1 = (Object)adaptor.becomeRoot(
 12194  
                         (Object)adaptor.create(TRIPLES_SAME_SUBJECT, "TRIPLES_SAME_SUBJECT")
 12195  
                         , root_1);
 12196  
 
 12197  2
                         adaptor.addChild(root_1, stream_triplesNode.nextTree());
 12198  
 
 12199  
                         // com\\googlecode\\sparkleg\\Sparql.g:366:79: ( propertyListNotEmpty )?
 12200  2
                         if ( stream_propertyListNotEmpty.hasNext() ) {
 12201  0
                             adaptor.addChild(root_1, stream_propertyListNotEmpty.nextTree());
 12202  
 
 12203  
                         }
 12204  2
                         stream_propertyListNotEmpty.reset();
 12205  
 
 12206  2
                         adaptor.addChild(root_0, root_1);
 12207  
                         }
 12208  
 
 12209  
                     }
 12210  
 
 12211  
 
 12212  2
                     retval.tree = root_0;
 12213  
 
 12214  
                     }
 12215  
                     break;
 12216  
 
 12217  
             }
 12218  194
             retval.stop = input.LT(-1);
 12219  
 
 12220  
 
 12221  194
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 12222  194
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 12223  
 
 12224  
         }
 12225  0
         catch (RecognitionException re) {
 12226  0
             reportError(re);
 12227  0
             recover(input,re);
 12228  0
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 12229  
 
 12230  
         }
 12231  
 
 12232  0
         finally {
 12233  
                 // do for sure before leaving
 12234  194
         }
 12235  194
         return retval;
 12236  
     }
 12237  
     // $ANTLR end "triplesSameSubject"
 12238  
 
 12239  
 
 12240  240
     public static class propertyListNotEmpty_return extends ParserRuleReturnScope {
 12241  
         Object tree;
 12242  240
         public Object getTree() { return tree; }
 12243  
     };
 12244  
 
 12245  
 
 12246  
     // $ANTLR start "propertyListNotEmpty"
 12247  
     // com\\googlecode\\sparkleg\\Sparql.g:369:1: propertyListNotEmpty : propertyListNotEmptyDetails ( SEMICOLON ( propertyListNotEmptyDetails )? )* -> ( propertyListNotEmptyDetails )+ ;
 12248  
     public final SparqlParser.propertyListNotEmpty_return propertyListNotEmpty() throws RecognitionException {
 12249  240
         SparqlParser.propertyListNotEmpty_return retval = new SparqlParser.propertyListNotEmpty_return();
 12250  240
         retval.start = input.LT(1);
 12251  
 
 12252  
 
 12253  240
         Object root_0 = null;
 12254  
 
 12255  240
         Token SEMICOLON270=null;
 12256  240
         SparqlParser.propertyListNotEmptyDetails_return propertyListNotEmptyDetails269 =null;
 12257  
 
 12258  240
         SparqlParser.propertyListNotEmptyDetails_return propertyListNotEmptyDetails271 =null;
 12259  
 
 12260  
 
 12261  240
         Object SEMICOLON270_tree=null;
 12262  240
         RewriteRuleTokenStream stream_SEMICOLON=new RewriteRuleTokenStream(adaptor,"token SEMICOLON");
 12263  240
         RewriteRuleSubtreeStream stream_propertyListNotEmptyDetails=new RewriteRuleSubtreeStream(adaptor,"rule propertyListNotEmptyDetails");
 12264  
         try {
 12265  
             // com\\googlecode\\sparkleg\\Sparql.g:370:5: ( propertyListNotEmptyDetails ( SEMICOLON ( propertyListNotEmptyDetails )? )* -> ( propertyListNotEmptyDetails )+ )
 12266  
             // com\\googlecode\\sparkleg\\Sparql.g:370:7: propertyListNotEmptyDetails ( SEMICOLON ( propertyListNotEmptyDetails )? )*
 12267  
             {
 12268  240
             pushFollow(FOLLOW_propertyListNotEmptyDetails_in_propertyListNotEmpty3058);
 12269  240
             propertyListNotEmptyDetails269=propertyListNotEmptyDetails();
 12270  
 
 12271  240
             state._fsp--;
 12272  
 
 12273  240
             stream_propertyListNotEmptyDetails.add(propertyListNotEmptyDetails269.getTree());
 12274  
 
 12275  
             // com\\googlecode\\sparkleg\\Sparql.g:370:35: ( SEMICOLON ( propertyListNotEmptyDetails )? )*
 12276  
             loop89:
 12277  
             do {
 12278  273
                 int alt89=2;
 12279  273
                 switch ( input.LA(1) ) {
 12280  
                 case SEMICOLON:
 12281  
                     {
 12282  33
                     alt89=1;
 12283  
                     }
 12284  
                     break;
 12285  
 
 12286  
                 }
 12287  
 
 12288  273
                 switch (alt89) {
 12289  
                     case 1 :
 12290  
                         // com\\googlecode\\sparkleg\\Sparql.g:370:36: SEMICOLON ( propertyListNotEmptyDetails )?
 12291  
                         {
 12292  33
                         SEMICOLON270=(Token)match(input,SEMICOLON,FOLLOW_SEMICOLON_in_propertyListNotEmpty3061);  
 12293  33
                         stream_SEMICOLON.add(SEMICOLON270);
 12294  
 
 12295  
 
 12296  
                         // com\\googlecode\\sparkleg\\Sparql.g:370:46: ( propertyListNotEmptyDetails )?
 12297  33
                         int alt88=2;
 12298  33
                         switch ( input.LA(1) ) {
 12299  
                             case A:
 12300  
                             case INVERSE:
 12301  
                             case IRI_REF:
 12302  
                             case NEGATION:
 12303  
                             case OPEN_BRACE:
 12304  
                             case PNAME_LN:
 12305  
                             case PNAME_NS:
 12306  
                             case VAR1:
 12307  
                             case VAR2:
 12308  
                                 {
 12309  32
                                 alt88=1;
 12310  
                                 }
 12311  
                                 break;
 12312  
                         }
 12313  
 
 12314  33
                         switch (alt88) {
 12315  
                             case 1 :
 12316  
                                 // com\\googlecode\\sparkleg\\Sparql.g:370:46: propertyListNotEmptyDetails
 12317  
                                 {
 12318  32
                                 pushFollow(FOLLOW_propertyListNotEmptyDetails_in_propertyListNotEmpty3063);
 12319  32
                                 propertyListNotEmptyDetails271=propertyListNotEmptyDetails();
 12320  
 
 12321  32
                                 state._fsp--;
 12322  
 
 12323  32
                                 stream_propertyListNotEmptyDetails.add(propertyListNotEmptyDetails271.getTree());
 12324  
 
 12325  
                                 }
 12326  
                                 break;
 12327  
 
 12328  
                         }
 12329  
 
 12330  
 
 12331  
                         }
 12332  33
                         break;
 12333  
 
 12334  
                     default :
 12335  240
                         break loop89;
 12336  
                 }
 12337  33
             } while (true);
 12338  
 
 12339  
 
 12340  
             // AST REWRITE
 12341  
             // elements: propertyListNotEmptyDetails
 12342  
             // token labels: 
 12343  
             // rule labels: retval
 12344  
             // token list labels: 
 12345  
             // rule list labels: 
 12346  
             // wildcard labels: 
 12347  240
             retval.tree = root_0;
 12348  240
             RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 12349  
 
 12350  240
             root_0 = (Object)adaptor.nil();
 12351  
             // 370:77: -> ( propertyListNotEmptyDetails )+
 12352  
             {
 12353  240
                 if ( !(stream_propertyListNotEmptyDetails.hasNext()) ) {
 12354  0
                     throw new RewriteEarlyExitException();
 12355  
                 }
 12356  512
                 while ( stream_propertyListNotEmptyDetails.hasNext() ) {
 12357  272
                     adaptor.addChild(root_0, stream_propertyListNotEmptyDetails.nextTree());
 12358  
 
 12359  
                 }
 12360  240
                 stream_propertyListNotEmptyDetails.reset();
 12361  
 
 12362  
             }
 12363  
 
 12364  
 
 12365  240
             retval.tree = root_0;
 12366  
 
 12367  
             }
 12368  
 
 12369  240
             retval.stop = input.LT(-1);
 12370  
 
 12371  
 
 12372  240
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 12373  240
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 12374  
 
 12375  
         }
 12376  0
         catch (RecognitionException re) {
 12377  0
             reportError(re);
 12378  0
             recover(input,re);
 12379  0
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 12380  
 
 12381  
         }
 12382  
 
 12383  0
         finally {
 12384  
                 // do for sure before leaving
 12385  240
         }
 12386  240
         return retval;
 12387  
     }
 12388  
     // $ANTLR end "propertyListNotEmpty"
 12389  
 
 12390  
 
 12391  3354
     public static class objectList_return extends ParserRuleReturnScope {
 12392  
         Object tree;
 12393  3354
         public Object getTree() { return tree; }
 12394  
     };
 12395  
 
 12396  
 
 12397  
     // $ANTLR start "objectList"
 12398  
     // com\\googlecode\\sparkleg\\Sparql.g:373:1: objectList : graphNode ( COMMA graphNode )* -> ( ^( OBJECT graphNode ) )+ ;
 12399  
     public final SparqlParser.objectList_return objectList() throws RecognitionException {
 12400  3354
         SparqlParser.objectList_return retval = new SparqlParser.objectList_return();
 12401  3354
         retval.start = input.LT(1);
 12402  
 
 12403  
 
 12404  3354
         Object root_0 = null;
 12405  
 
 12406  3354
         Token COMMA273=null;
 12407  3354
         SparqlParser.graphNode_return graphNode272 =null;
 12408  
 
 12409  3354
         SparqlParser.graphNode_return graphNode274 =null;
 12410  
 
 12411  
 
 12412  3354
         Object COMMA273_tree=null;
 12413  3354
         RewriteRuleTokenStream stream_COMMA=new RewriteRuleTokenStream(adaptor,"token COMMA");
 12414  3354
         RewriteRuleSubtreeStream stream_graphNode=new RewriteRuleSubtreeStream(adaptor,"rule graphNode");
 12415  
         try {
 12416  
             // com\\googlecode\\sparkleg\\Sparql.g:374:5: ( graphNode ( COMMA graphNode )* -> ( ^( OBJECT graphNode ) )+ )
 12417  
             // com\\googlecode\\sparkleg\\Sparql.g:374:7: graphNode ( COMMA graphNode )*
 12418  
             {
 12419  3354
             pushFollow(FOLLOW_graphNode_in_objectList3089);
 12420  3354
             graphNode272=graphNode();
 12421  
 
 12422  3354
             state._fsp--;
 12423  
 
 12424  3354
             stream_graphNode.add(graphNode272.getTree());
 12425  
 
 12426  
             // com\\googlecode\\sparkleg\\Sparql.g:374:17: ( COMMA graphNode )*
 12427  
             loop90:
 12428  
             do {
 12429  3358
                 int alt90=2;
 12430  3358
                 switch ( input.LA(1) ) {
 12431  
                 case COMMA:
 12432  
                     {
 12433  4
                     alt90=1;
 12434  
                     }
 12435  
                     break;
 12436  
 
 12437  
                 }
 12438  
 
 12439  3358
                 switch (alt90) {
 12440  
                     case 1 :
 12441  
                         // com\\googlecode\\sparkleg\\Sparql.g:374:18: COMMA graphNode
 12442  
                         {
 12443  4
                         COMMA273=(Token)match(input,COMMA,FOLLOW_COMMA_in_objectList3092);  
 12444  4
                         stream_COMMA.add(COMMA273);
 12445  
 
 12446  
 
 12447  4
                         pushFollow(FOLLOW_graphNode_in_objectList3094);
 12448  4
                         graphNode274=graphNode();
 12449  
 
 12450  4
                         state._fsp--;
 12451  
 
 12452  4
                         stream_graphNode.add(graphNode274.getTree());
 12453  
 
 12454  
                         }
 12455  4
                         break;
 12456  
 
 12457  
                     default :
 12458  3354
                         break loop90;
 12459  
                 }
 12460  4
             } while (true);
 12461  
 
 12462  
 
 12463  
             // AST REWRITE
 12464  
             // elements: graphNode
 12465  
             // token labels: 
 12466  
             // rule labels: retval
 12467  
             // token list labels: 
 12468  
             // rule list labels: 
 12469  
             // wildcard labels: 
 12470  3354
             retval.tree = root_0;
 12471  3354
             RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 12472  
 
 12473  3354
             root_0 = (Object)adaptor.nil();
 12474  
             // 374:36: -> ( ^( OBJECT graphNode ) )+
 12475  
             {
 12476  3354
                 if ( !(stream_graphNode.hasNext()) ) {
 12477  0
                     throw new RewriteEarlyExitException();
 12478  
                 }
 12479  6712
                 while ( stream_graphNode.hasNext() ) {
 12480  
                     // com\\googlecode\\sparkleg\\Sparql.g:374:39: ^( OBJECT graphNode )
 12481  
                     {
 12482  3358
                     Object root_1 = (Object)adaptor.nil();
 12483  3358
                     root_1 = (Object)adaptor.becomeRoot(
 12484  
                     (Object)adaptor.create(OBJECT, "OBJECT")
 12485  
                     , root_1);
 12486  
 
 12487  3358
                     adaptor.addChild(root_1, stream_graphNode.nextTree());
 12488  
 
 12489  3358
                     adaptor.addChild(root_0, root_1);
 12490  3358
                     }
 12491  
 
 12492  
                 }
 12493  3354
                 stream_graphNode.reset();
 12494  
 
 12495  
             }
 12496  
 
 12497  
 
 12498  3354
             retval.tree = root_0;
 12499  
 
 12500  
             }
 12501  
 
 12502  3354
             retval.stop = input.LT(-1);
 12503  
 
 12504  
 
 12505  3354
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 12506  3354
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 12507  
 
 12508  
         }
 12509  0
         catch (RecognitionException re) {
 12510  0
             reportError(re);
 12511  0
             recover(input,re);
 12512  0
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 12513  
 
 12514  
         }
 12515  
 
 12516  0
         finally {
 12517  
                 // do for sure before leaving
 12518  3354
         }
 12519  3354
         return retval;
 12520  
     }
 12521  
     // $ANTLR end "objectList"
 12522  
 
 12523  
 
 12524  0
     public static class verb_return extends ParserRuleReturnScope {
 12525  
         Object tree;
 12526  0
         public Object getTree() { return tree; }
 12527  
     };
 12528  
 
 12529  
 
 12530  
     // $ANTLR start "verb"
 12531  
     // com\\googlecode\\sparkleg\\Sparql.g:377:1: verb : ( varOrIRIref | A );
 12532  
     public final SparqlParser.verb_return verb() throws RecognitionException {
 12533  0
         SparqlParser.verb_return retval = new SparqlParser.verb_return();
 12534  0
         retval.start = input.LT(1);
 12535  
 
 12536  
 
 12537  0
         Object root_0 = null;
 12538  
 
 12539  0
         Token A276=null;
 12540  0
         SparqlParser.varOrIRIref_return varOrIRIref275 =null;
 12541  
 
 12542  
 
 12543  0
         Object A276_tree=null;
 12544  
 
 12545  
         try {
 12546  
             // com\\googlecode\\sparkleg\\Sparql.g:378:5: ( varOrIRIref | A )
 12547  0
             int alt91=2;
 12548  0
             switch ( input.LA(1) ) {
 12549  
             case IRI_REF:
 12550  
             case PNAME_LN:
 12551  
             case PNAME_NS:
 12552  
             case VAR1:
 12553  
             case VAR2:
 12554  
                 {
 12555  0
                 alt91=1;
 12556  
                 }
 12557  0
                 break;
 12558  
             case A:
 12559  
                 {
 12560  0
                 alt91=2;
 12561  
                 }
 12562  0
                 break;
 12563  
             default:
 12564  0
                 NoViableAltException nvae =
 12565  
                     new NoViableAltException("", 91, 0, input);
 12566  
 
 12567  0
                 throw nvae;
 12568  
 
 12569  
             }
 12570  
 
 12571  0
             switch (alt91) {
 12572  
                 case 1 :
 12573  
                     // com\\googlecode\\sparkleg\\Sparql.g:378:7: varOrIRIref
 12574  
                     {
 12575  0
                     root_0 = (Object)adaptor.nil();
 12576  
 
 12577  
 
 12578  0
                     pushFollow(FOLLOW_varOrIRIref_in_verb3122);
 12579  0
                     varOrIRIref275=varOrIRIref();
 12580  
 
 12581  0
                     state._fsp--;
 12582  
 
 12583  0
                     adaptor.addChild(root_0, varOrIRIref275.getTree());
 12584  
 
 12585  
                     }
 12586  0
                     break;
 12587  
                 case 2 :
 12588  
                     // com\\googlecode\\sparkleg\\Sparql.g:379:7: A
 12589  
                     {
 12590  0
                     root_0 = (Object)adaptor.nil();
 12591  
 
 12592  
 
 12593  0
                     A276=(Token)match(input,A,FOLLOW_A_in_verb3130); 
 12594  0
                     A276_tree = 
 12595  
                     (Object)adaptor.create(A276)
 12596  
                     ;
 12597  0
                     adaptor.addChild(root_0, A276_tree);
 12598  
 
 12599  
 
 12600  
                     }
 12601  
                     break;
 12602  
 
 12603  
             }
 12604  0
             retval.stop = input.LT(-1);
 12605  
 
 12606  
 
 12607  0
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 12608  0
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 12609  
 
 12610  
         }
 12611  0
         catch (RecognitionException re) {
 12612  0
             reportError(re);
 12613  0
             recover(input,re);
 12614  0
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 12615  
 
 12616  
         }
 12617  
 
 12618  0
         finally {
 12619  
                 // do for sure before leaving
 12620  0
         }
 12621  0
         return retval;
 12622  
     }
 12623  
     // $ANTLR end "verb"
 12624  
 
 12625  
 
 12626  2914
     public static class triplesSameSubjectPath_return extends ParserRuleReturnScope {
 12627  
         Object tree;
 12628  2914
         public Object getTree() { return tree; }
 12629  
     };
 12630  
 
 12631  
 
 12632  
     // $ANTLR start "triplesSameSubjectPath"
 12633  
     // com\\googlecode\\sparkleg\\Sparql.g:382:1: triplesSameSubjectPath : ( varOrTerm propertyListNotEmptyPath -> ^( TRIPLES_SAME_SUBJECT ^( SUBJECT varOrTerm ) propertyListNotEmptyPath ) | triplesNode ( propertyListNotEmpty )? -> ^( TRIPLES_SAME_SUBJECT triplesNode ( propertyListNotEmpty )? ) );
 12634  
     public final SparqlParser.triplesSameSubjectPath_return triplesSameSubjectPath() throws RecognitionException {
 12635  2914
         SparqlParser.triplesSameSubjectPath_return retval = new SparqlParser.triplesSameSubjectPath_return();
 12636  2914
         retval.start = input.LT(1);
 12637  
 
 12638  
 
 12639  2914
         Object root_0 = null;
 12640  
 
 12641  2914
         SparqlParser.varOrTerm_return varOrTerm277 =null;
 12642  
 
 12643  2914
         SparqlParser.propertyListNotEmptyPath_return propertyListNotEmptyPath278 =null;
 12644  
 
 12645  2914
         SparqlParser.triplesNode_return triplesNode279 =null;
 12646  
 
 12647  2914
         SparqlParser.propertyListNotEmpty_return propertyListNotEmpty280 =null;
 12648  
 
 12649  
 
 12650  2914
         RewriteRuleSubtreeStream stream_propertyListNotEmpty=new RewriteRuleSubtreeStream(adaptor,"rule propertyListNotEmpty");
 12651  2914
         RewriteRuleSubtreeStream stream_varOrTerm=new RewriteRuleSubtreeStream(adaptor,"rule varOrTerm");
 12652  2914
         RewriteRuleSubtreeStream stream_triplesNode=new RewriteRuleSubtreeStream(adaptor,"rule triplesNode");
 12653  2914
         RewriteRuleSubtreeStream stream_propertyListNotEmptyPath=new RewriteRuleSubtreeStream(adaptor,"rule propertyListNotEmptyPath");
 12654  
         try {
 12655  
             // com\\googlecode\\sparkleg\\Sparql.g:383:5: ( varOrTerm propertyListNotEmptyPath -> ^( TRIPLES_SAME_SUBJECT ^( SUBJECT varOrTerm ) propertyListNotEmptyPath ) | triplesNode ( propertyListNotEmpty )? -> ^( TRIPLES_SAME_SUBJECT triplesNode ( propertyListNotEmpty )? ) )
 12656  2914
             int alt93=2;
 12657  2914
             switch ( input.LA(1) ) {
 12658  
             case BLANK_NODE_LABEL:
 12659  
             case DECIMAL:
 12660  
             case DECIMAL_NEGATIVE:
 12661  
             case DECIMAL_POSITIVE:
 12662  
             case DOUBLE:
 12663  
             case DOUBLE_NEGATIVE:
 12664  
             case DOUBLE_POSITIVE:
 12665  
             case FALSE:
 12666  
             case INTEGER:
 12667  
             case INTEGER_NEGATIVE:
 12668  
             case INTEGER_POSITIVE:
 12669  
             case IRI_REF:
 12670  
             case PNAME_LN:
 12671  
             case PNAME_NS:
 12672  
             case STRING_LITERAL1:
 12673  
             case STRING_LITERAL2:
 12674  
             case STRING_LITERAL_LONG1:
 12675  
             case STRING_LITERAL_LONG2:
 12676  
             case TRUE:
 12677  
             case VAR1:
 12678  
             case VAR2:
 12679  
                 {
 12680  2826
                 alt93=1;
 12681  
                 }
 12682  2826
                 break;
 12683  
             case OPEN_SQUARE_BRACKET:
 12684  
                 {
 12685  66
                 switch ( input.LA(2) ) {
 12686  
                 case CLOSE_SQUARE_BRACKET:
 12687  
                     {
 12688  52
                     alt93=1;
 12689  
                     }
 12690  52
                     break;
 12691  
                 case A:
 12692  
                 case INVERSE:
 12693  
                 case IRI_REF:
 12694  
                 case NEGATION:
 12695  
                 case OPEN_BRACE:
 12696  
                 case PNAME_LN:
 12697  
                 case PNAME_NS:
 12698  
                 case VAR1:
 12699  
                 case VAR2:
 12700  
                     {
 12701  14
                     alt93=2;
 12702  
                     }
 12703  14
                     break;
 12704  
                 default:
 12705  0
                     NoViableAltException nvae =
 12706  
                         new NoViableAltException("", 93, 2, input);
 12707  
 
 12708  0
                     throw nvae;
 12709  
 
 12710  
                 }
 12711  
 
 12712  
                 }
 12713  66
                 break;
 12714  
             case OPEN_BRACE:
 12715  
                 {
 12716  22
                 switch ( input.LA(2) ) {
 12717  
                 case CLOSE_BRACE:
 12718  
                     {
 12719  6
                     alt93=1;
 12720  
                     }
 12721  6
                     break;
 12722  
                 case BLANK_NODE_LABEL:
 12723  
                 case DECIMAL:
 12724  
                 case DECIMAL_NEGATIVE:
 12725  
                 case DECIMAL_POSITIVE:
 12726  
                 case DOUBLE:
 12727  
                 case DOUBLE_NEGATIVE:
 12728  
                 case DOUBLE_POSITIVE:
 12729  
                 case FALSE:
 12730  
                 case INTEGER:
 12731  
                 case INTEGER_NEGATIVE:
 12732  
                 case INTEGER_POSITIVE:
 12733  
                 case IRI_REF:
 12734  
                 case OPEN_BRACE:
 12735  
                 case OPEN_SQUARE_BRACKET:
 12736  
                 case PNAME_LN:
 12737  
                 case PNAME_NS:
 12738  
                 case STRING_LITERAL1:
 12739  
                 case STRING_LITERAL2:
 12740  
                 case STRING_LITERAL_LONG1:
 12741  
                 case STRING_LITERAL_LONG2:
 12742  
                 case TRUE:
 12743  
                 case VAR1:
 12744  
                 case VAR2:
 12745  
                     {
 12746  16
                     alt93=2;
 12747  
                     }
 12748  16
                     break;
 12749  
                 default:
 12750  0
                     NoViableAltException nvae =
 12751  
                         new NoViableAltException("", 93, 3, input);
 12752  
 
 12753  0
                     throw nvae;
 12754  
 
 12755  
                 }
 12756  
 
 12757  
                 }
 12758  22
                 break;
 12759  
             default:
 12760  0
                 NoViableAltException nvae =
 12761  
                     new NoViableAltException("", 93, 0, input);
 12762  
 
 12763  0
                 throw nvae;
 12764  
 
 12765  
             }
 12766  
 
 12767  2914
             switch (alt93) {
 12768  
                 case 1 :
 12769  
                     // com\\googlecode\\sparkleg\\Sparql.g:383:7: varOrTerm propertyListNotEmptyPath
 12770  
                     {
 12771  2884
                     pushFollow(FOLLOW_varOrTerm_in_triplesSameSubjectPath3147);
 12772  2884
                     varOrTerm277=varOrTerm();
 12773  
 
 12774  2884
                     state._fsp--;
 12775  
 
 12776  2884
                     stream_varOrTerm.add(varOrTerm277.getTree());
 12777  
 
 12778  2884
                     pushFollow(FOLLOW_propertyListNotEmptyPath_in_triplesSameSubjectPath3149);
 12779  2884
                     propertyListNotEmptyPath278=propertyListNotEmptyPath();
 12780  
 
 12781  2884
                     state._fsp--;
 12782  
 
 12783  2884
                     stream_propertyListNotEmptyPath.add(propertyListNotEmptyPath278.getTree());
 12784  
 
 12785  
                     // AST REWRITE
 12786  
                     // elements: propertyListNotEmptyPath, varOrTerm
 12787  
                     // token labels: 
 12788  
                     // rule labels: retval
 12789  
                     // token list labels: 
 12790  
                     // rule list labels: 
 12791  
                     // wildcard labels: 
 12792  2884
                     retval.tree = root_0;
 12793  2884
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 12794  
 
 12795  2884
                     root_0 = (Object)adaptor.nil();
 12796  
                     // 383:42: -> ^( TRIPLES_SAME_SUBJECT ^( SUBJECT varOrTerm ) propertyListNotEmptyPath )
 12797  
                     {
 12798  
                         // com\\googlecode\\sparkleg\\Sparql.g:383:45: ^( TRIPLES_SAME_SUBJECT ^( SUBJECT varOrTerm ) propertyListNotEmptyPath )
 12799  
                         {
 12800  2884
                         Object root_1 = (Object)adaptor.nil();
 12801  2884
                         root_1 = (Object)adaptor.becomeRoot(
 12802  
                         (Object)adaptor.create(TRIPLES_SAME_SUBJECT, "TRIPLES_SAME_SUBJECT")
 12803  
                         , root_1);
 12804  
 
 12805  
                         // com\\googlecode\\sparkleg\\Sparql.g:383:68: ^( SUBJECT varOrTerm )
 12806  
                         {
 12807  2884
                         Object root_2 = (Object)adaptor.nil();
 12808  2884
                         root_2 = (Object)adaptor.becomeRoot(
 12809  
                         (Object)adaptor.create(SUBJECT, "SUBJECT")
 12810  
                         , root_2);
 12811  
 
 12812  2884
                         adaptor.addChild(root_2, stream_varOrTerm.nextTree());
 12813  
 
 12814  2884
                         adaptor.addChild(root_1, root_2);
 12815  
                         }
 12816  
 
 12817  2884
                         adaptor.addChild(root_1, stream_propertyListNotEmptyPath.nextTree());
 12818  
 
 12819  2884
                         adaptor.addChild(root_0, root_1);
 12820  
                         }
 12821  
 
 12822  
                     }
 12823  
 
 12824  
 
 12825  2884
                     retval.tree = root_0;
 12826  
 
 12827  
                     }
 12828  2884
                     break;
 12829  
                 case 2 :
 12830  
                     // com\\googlecode\\sparkleg\\Sparql.g:384:7: triplesNode ( propertyListNotEmpty )?
 12831  
                     {
 12832  30
                     pushFollow(FOLLOW_triplesNode_in_triplesSameSubjectPath3171);
 12833  30
                     triplesNode279=triplesNode();
 12834  
 
 12835  30
                     state._fsp--;
 12836  
 
 12837  30
                     stream_triplesNode.add(triplesNode279.getTree());
 12838  
 
 12839  
                     // com\\googlecode\\sparkleg\\Sparql.g:384:19: ( propertyListNotEmpty )?
 12840  30
                     int alt92=2;
 12841  30
                     switch ( input.LA(1) ) {
 12842  
                         case A:
 12843  
                         case INVERSE:
 12844  
                         case IRI_REF:
 12845  
                         case NEGATION:
 12846  
                         case OPEN_BRACE:
 12847  
                         case PNAME_LN:
 12848  
                         case PNAME_NS:
 12849  
                         case VAR1:
 12850  
                         case VAR2:
 12851  
                             {
 12852  10
                             alt92=1;
 12853  
                             }
 12854  
                             break;
 12855  
                     }
 12856  
 
 12857  30
                     switch (alt92) {
 12858  
                         case 1 :
 12859  
                             // com\\googlecode\\sparkleg\\Sparql.g:384:19: propertyListNotEmpty
 12860  
                             {
 12861  10
                             pushFollow(FOLLOW_propertyListNotEmpty_in_triplesSameSubjectPath3173);
 12862  10
                             propertyListNotEmpty280=propertyListNotEmpty();
 12863  
 
 12864  10
                             state._fsp--;
 12865  
 
 12866  10
                             stream_propertyListNotEmpty.add(propertyListNotEmpty280.getTree());
 12867  
 
 12868  
                             }
 12869  
                             break;
 12870  
 
 12871  
                     }
 12872  
 
 12873  
 
 12874  
                     // AST REWRITE
 12875  
                     // elements: propertyListNotEmpty, triplesNode
 12876  
                     // token labels: 
 12877  
                     // rule labels: retval
 12878  
                     // token list labels: 
 12879  
                     // rule list labels: 
 12880  
                     // wildcard labels: 
 12881  30
                     retval.tree = root_0;
 12882  30
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 12883  
 
 12884  30
                     root_0 = (Object)adaptor.nil();
 12885  
                     // 384:41: -> ^( TRIPLES_SAME_SUBJECT triplesNode ( propertyListNotEmpty )? )
 12886  
                     {
 12887  
                         // com\\googlecode\\sparkleg\\Sparql.g:384:44: ^( TRIPLES_SAME_SUBJECT triplesNode ( propertyListNotEmpty )? )
 12888  
                         {
 12889  30
                         Object root_1 = (Object)adaptor.nil();
 12890  30
                         root_1 = (Object)adaptor.becomeRoot(
 12891  
                         (Object)adaptor.create(TRIPLES_SAME_SUBJECT, "TRIPLES_SAME_SUBJECT")
 12892  
                         , root_1);
 12893  
 
 12894  30
                         adaptor.addChild(root_1, stream_triplesNode.nextTree());
 12895  
 
 12896  
                         // com\\googlecode\\sparkleg\\Sparql.g:384:80: ( propertyListNotEmpty )?
 12897  30
                         if ( stream_propertyListNotEmpty.hasNext() ) {
 12898  10
                             adaptor.addChild(root_1, stream_propertyListNotEmpty.nextTree());
 12899  
 
 12900  
                         }
 12901  30
                         stream_propertyListNotEmpty.reset();
 12902  
 
 12903  30
                         adaptor.addChild(root_0, root_1);
 12904  
                         }
 12905  
 
 12906  
                     }
 12907  
 
 12908  
 
 12909  30
                     retval.tree = root_0;
 12910  
 
 12911  
                     }
 12912  
                     break;
 12913  
 
 12914  
             }
 12915  2914
             retval.stop = input.LT(-1);
 12916  
 
 12917  
 
 12918  2914
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 12919  2914
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 12920  
 
 12921  
         }
 12922  0
         catch (RecognitionException re) {
 12923  0
             reportError(re);
 12924  0
             recover(input,re);
 12925  0
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 12926  
 
 12927  
         }
 12928  
 
 12929  0
         finally {
 12930  
                 // do for sure before leaving
 12931  2914
         }
 12932  2914
         return retval;
 12933  
     }
 12934  
     // $ANTLR end "triplesSameSubjectPath"
 12935  
 
 12936  
 
 12937  2884
     public static class propertyListNotEmptyPath_return extends ParserRuleReturnScope {
 12938  
         Object tree;
 12939  2884
         public Object getTree() { return tree; }
 12940  
     };
 12941  
 
 12942  
 
 12943  
     // $ANTLR start "propertyListNotEmptyPath"
 12944  
     // com\\googlecode\\sparkleg\\Sparql.g:387:1: propertyListNotEmptyPath : propertyListNotEmptyDetails ( SEMICOLON ( propertyListNotEmptyDetails )? )* -> ( propertyListNotEmptyDetails )+ ;
 12945  
     public final SparqlParser.propertyListNotEmptyPath_return propertyListNotEmptyPath() throws RecognitionException {
 12946  2884
         SparqlParser.propertyListNotEmptyPath_return retval = new SparqlParser.propertyListNotEmptyPath_return();
 12947  2884
         retval.start = input.LT(1);
 12948  
 
 12949  
 
 12950  2884
         Object root_0 = null;
 12951  
 
 12952  2884
         Token SEMICOLON282=null;
 12953  2884
         SparqlParser.propertyListNotEmptyDetails_return propertyListNotEmptyDetails281 =null;
 12954  
 
 12955  2884
         SparqlParser.propertyListNotEmptyDetails_return propertyListNotEmptyDetails283 =null;
 12956  
 
 12957  
 
 12958  2884
         Object SEMICOLON282_tree=null;
 12959  2884
         RewriteRuleTokenStream stream_SEMICOLON=new RewriteRuleTokenStream(adaptor,"token SEMICOLON");
 12960  2884
         RewriteRuleSubtreeStream stream_propertyListNotEmptyDetails=new RewriteRuleSubtreeStream(adaptor,"rule propertyListNotEmptyDetails");
 12961  
         try {
 12962  
             // com\\googlecode\\sparkleg\\Sparql.g:388:5: ( propertyListNotEmptyDetails ( SEMICOLON ( propertyListNotEmptyDetails )? )* -> ( propertyListNotEmptyDetails )+ )
 12963  
             // com\\googlecode\\sparkleg\\Sparql.g:388:7: propertyListNotEmptyDetails ( SEMICOLON ( propertyListNotEmptyDetails )? )*
 12964  
             {
 12965  2884
             pushFollow(FOLLOW_propertyListNotEmptyDetails_in_propertyListNotEmptyPath3205);
 12966  2884
             propertyListNotEmptyDetails281=propertyListNotEmptyDetails();
 12967  
 
 12968  2884
             state._fsp--;
 12969  
 
 12970  2884
             stream_propertyListNotEmptyDetails.add(propertyListNotEmptyDetails281.getTree());
 12971  
 
 12972  
             // com\\googlecode\\sparkleg\\Sparql.g:388:35: ( SEMICOLON ( propertyListNotEmptyDetails )? )*
 12973  
             loop95:
 12974  
             do {
 12975  3086
                 int alt95=2;
 12976  3086
                 switch ( input.LA(1) ) {
 12977  
                 case SEMICOLON:
 12978  
                     {
 12979  202
                     alt95=1;
 12980  
                     }
 12981  
                     break;
 12982  
 
 12983  
                 }
 12984  
 
 12985  3086
                 switch (alt95) {
 12986  
                     case 1 :
 12987  
                         // com\\googlecode\\sparkleg\\Sparql.g:388:36: SEMICOLON ( propertyListNotEmptyDetails )?
 12988  
                         {
 12989  202
                         SEMICOLON282=(Token)match(input,SEMICOLON,FOLLOW_SEMICOLON_in_propertyListNotEmptyPath3208);  
 12990  202
                         stream_SEMICOLON.add(SEMICOLON282);
 12991  
 
 12992  
 
 12993  
                         // com\\googlecode\\sparkleg\\Sparql.g:388:46: ( propertyListNotEmptyDetails )?
 12994  202
                         int alt94=2;
 12995  202
                         switch ( input.LA(1) ) {
 12996  
                             case A:
 12997  
                             case INVERSE:
 12998  
                             case IRI_REF:
 12999  
                             case NEGATION:
 13000  
                             case OPEN_BRACE:
 13001  
                             case PNAME_LN:
 13002  
                             case PNAME_NS:
 13003  
                             case VAR1:
 13004  
                             case VAR2:
 13005  
                                 {
 13006  198
                                 alt94=1;
 13007  
                                 }
 13008  
                                 break;
 13009  
                         }
 13010  
 
 13011  202
                         switch (alt94) {
 13012  
                             case 1 :
 13013  
                                 // com\\googlecode\\sparkleg\\Sparql.g:388:46: propertyListNotEmptyDetails
 13014  
                                 {
 13015  198
                                 pushFollow(FOLLOW_propertyListNotEmptyDetails_in_propertyListNotEmptyPath3210);
 13016  198
                                 propertyListNotEmptyDetails283=propertyListNotEmptyDetails();
 13017  
 
 13018  198
                                 state._fsp--;
 13019  
 
 13020  198
                                 stream_propertyListNotEmptyDetails.add(propertyListNotEmptyDetails283.getTree());
 13021  
 
 13022  
                                 }
 13023  
                                 break;
 13024  
 
 13025  
                         }
 13026  
 
 13027  
 
 13028  
                         }
 13029  202
                         break;
 13030  
 
 13031  
                     default :
 13032  2884
                         break loop95;
 13033  
                 }
 13034  202
             } while (true);
 13035  
 
 13036  
 
 13037  
             // AST REWRITE
 13038  
             // elements: propertyListNotEmptyDetails
 13039  
             // token labels: 
 13040  
             // rule labels: retval
 13041  
             // token list labels: 
 13042  
             // rule list labels: 
 13043  
             // wildcard labels: 
 13044  2884
             retval.tree = root_0;
 13045  2884
             RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 13046  
 
 13047  2884
             root_0 = (Object)adaptor.nil();
 13048  
             // 388:77: -> ( propertyListNotEmptyDetails )+
 13049  
             {
 13050  2884
                 if ( !(stream_propertyListNotEmptyDetails.hasNext()) ) {
 13051  0
                     throw new RewriteEarlyExitException();
 13052  
                 }
 13053  5966
                 while ( stream_propertyListNotEmptyDetails.hasNext() ) {
 13054  3082
                     adaptor.addChild(root_0, stream_propertyListNotEmptyDetails.nextTree());
 13055  
 
 13056  
                 }
 13057  2884
                 stream_propertyListNotEmptyDetails.reset();
 13058  
 
 13059  
             }
 13060  
 
 13061  
 
 13062  2884
             retval.tree = root_0;
 13063  
 
 13064  
             }
 13065  
 
 13066  2884
             retval.stop = input.LT(-1);
 13067  
 
 13068  
 
 13069  2884
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 13070  2884
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 13071  
 
 13072  
         }
 13073  0
         catch (RecognitionException re) {
 13074  0
             reportError(re);
 13075  0
             recover(input,re);
 13076  0
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 13077  
 
 13078  
         }
 13079  
 
 13080  0
         finally {
 13081  
                 // do for sure before leaving
 13082  2884
         }
 13083  2884
         return retval;
 13084  
     }
 13085  
     // $ANTLR end "propertyListNotEmptyPath"
 13086  
 
 13087  
 
 13088  3354
     public static class propertyListNotEmptyDetails_return extends ParserRuleReturnScope {
 13089  
         Object tree;
 13090  3354
         public Object getTree() { return tree; }
 13091  
     };
 13092  
 
 13093  
 
 13094  
     // $ANTLR start "propertyListNotEmptyDetails"
 13095  
     // com\\googlecode\\sparkleg\\Sparql.g:391:1: propertyListNotEmptyDetails : verbSimpleOrPath objectList -> ^( PREDICATE verbSimpleOrPath objectList ) ;
 13096  
     public final SparqlParser.propertyListNotEmptyDetails_return propertyListNotEmptyDetails() throws RecognitionException {
 13097  3354
         SparqlParser.propertyListNotEmptyDetails_return retval = new SparqlParser.propertyListNotEmptyDetails_return();
 13098  3354
         retval.start = input.LT(1);
 13099  
 
 13100  
 
 13101  3354
         Object root_0 = null;
 13102  
 
 13103  3354
         SparqlParser.verbSimpleOrPath_return verbSimpleOrPath284 =null;
 13104  
 
 13105  3354
         SparqlParser.objectList_return objectList285 =null;
 13106  
 
 13107  
 
 13108  3354
         RewriteRuleSubtreeStream stream_verbSimpleOrPath=new RewriteRuleSubtreeStream(adaptor,"rule verbSimpleOrPath");
 13109  3354
         RewriteRuleSubtreeStream stream_objectList=new RewriteRuleSubtreeStream(adaptor,"rule objectList");
 13110  
         try {
 13111  
             // com\\googlecode\\sparkleg\\Sparql.g:392:5: ( verbSimpleOrPath objectList -> ^( PREDICATE verbSimpleOrPath objectList ) )
 13112  
             // com\\googlecode\\sparkleg\\Sparql.g:392:7: verbSimpleOrPath objectList
 13113  
             {
 13114  3354
             pushFollow(FOLLOW_verbSimpleOrPath_in_propertyListNotEmptyDetails3237);
 13115  3354
             verbSimpleOrPath284=verbSimpleOrPath();
 13116  
 
 13117  3354
             state._fsp--;
 13118  
 
 13119  3354
             stream_verbSimpleOrPath.add(verbSimpleOrPath284.getTree());
 13120  
 
 13121  3354
             pushFollow(FOLLOW_objectList_in_propertyListNotEmptyDetails3239);
 13122  3354
             objectList285=objectList();
 13123  
 
 13124  3354
             state._fsp--;
 13125  
 
 13126  3354
             stream_objectList.add(objectList285.getTree());
 13127  
 
 13128  
             // AST REWRITE
 13129  
             // elements: verbSimpleOrPath, objectList
 13130  
             // token labels: 
 13131  
             // rule labels: retval
 13132  
             // token list labels: 
 13133  
             // rule list labels: 
 13134  
             // wildcard labels: 
 13135  3354
             retval.tree = root_0;
 13136  3354
             RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 13137  
 
 13138  3354
             root_0 = (Object)adaptor.nil();
 13139  
             // 392:35: -> ^( PREDICATE verbSimpleOrPath objectList )
 13140  
             {
 13141  
                 // com\\googlecode\\sparkleg\\Sparql.g:392:38: ^( PREDICATE verbSimpleOrPath objectList )
 13142  
                 {
 13143  3354
                 Object root_1 = (Object)adaptor.nil();
 13144  3354
                 root_1 = (Object)adaptor.becomeRoot(
 13145  
                 (Object)adaptor.create(PREDICATE, "PREDICATE")
 13146  
                 , root_1);
 13147  
 
 13148  3354
                 adaptor.addChild(root_1, stream_verbSimpleOrPath.nextTree());
 13149  
 
 13150  3354
                 adaptor.addChild(root_1, stream_objectList.nextTree());
 13151  
 
 13152  3354
                 adaptor.addChild(root_0, root_1);
 13153  
                 }
 13154  
 
 13155  
             }
 13156  
 
 13157  
 
 13158  3354
             retval.tree = root_0;
 13159  
 
 13160  
             }
 13161  
 
 13162  3354
             retval.stop = input.LT(-1);
 13163  
 
 13164  
 
 13165  3354
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 13166  3354
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 13167  
 
 13168  
         }
 13169  0
         catch (RecognitionException re) {
 13170  0
             reportError(re);
 13171  0
             recover(input,re);
 13172  0
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 13173  
 
 13174  
         }
 13175  
 
 13176  0
         finally {
 13177  
                 // do for sure before leaving
 13178  3354
         }
 13179  3354
         return retval;
 13180  
     }
 13181  
     // $ANTLR end "propertyListNotEmptyDetails"
 13182  
 
 13183  
 
 13184  3354
     public static class verbSimpleOrPath_return extends ParserRuleReturnScope {
 13185  
         Object tree;
 13186  3354
         public Object getTree() { return tree; }
 13187  
     };
 13188  
 
 13189  
 
 13190  
     // $ANTLR start "verbSimpleOrPath"
 13191  
     // com\\googlecode\\sparkleg\\Sparql.g:395:1: verbSimpleOrPath : ( verbPath | verbSimple );
 13192  
     public final SparqlParser.verbSimpleOrPath_return verbSimpleOrPath() throws RecognitionException {
 13193  3354
         SparqlParser.verbSimpleOrPath_return retval = new SparqlParser.verbSimpleOrPath_return();
 13194  3354
         retval.start = input.LT(1);
 13195  
 
 13196  
 
 13197  3354
         Object root_0 = null;
 13198  
 
 13199  3354
         SparqlParser.verbPath_return verbPath286 =null;
 13200  
 
 13201  3354
         SparqlParser.verbSimple_return verbSimple287 =null;
 13202  
 
 13203  
 
 13204  
 
 13205  
         try {
 13206  
             // com\\googlecode\\sparkleg\\Sparql.g:396:5: ( verbPath | verbSimple )
 13207  3354
             int alt96=2;
 13208  3354
             switch ( input.LA(1) ) {
 13209  
             case A:
 13210  
             case INVERSE:
 13211  
             case IRI_REF:
 13212  
             case NEGATION:
 13213  
             case OPEN_BRACE:
 13214  
             case PNAME_LN:
 13215  
             case PNAME_NS:
 13216  
                 {
 13217  2666
                 alt96=1;
 13218  
                 }
 13219  2666
                 break;
 13220  
             case VAR1:
 13221  
             case VAR2:
 13222  
                 {
 13223  688
                 alt96=2;
 13224  
                 }
 13225  688
                 break;
 13226  
             default:
 13227  0
                 NoViableAltException nvae =
 13228  
                     new NoViableAltException("", 96, 0, input);
 13229  
 
 13230  0
                 throw nvae;
 13231  
 
 13232  
             }
 13233  
 
 13234  3354
             switch (alt96) {
 13235  
                 case 1 :
 13236  
                     // com\\googlecode\\sparkleg\\Sparql.g:396:7: verbPath
 13237  
                     {
 13238  2666
                     root_0 = (Object)adaptor.nil();
 13239  
 
 13240  
 
 13241  2666
                     pushFollow(FOLLOW_verbPath_in_verbSimpleOrPath3269);
 13242  2666
                     verbPath286=verbPath();
 13243  
 
 13244  2666
                     state._fsp--;
 13245  
 
 13246  2666
                     adaptor.addChild(root_0, verbPath286.getTree());
 13247  
 
 13248  
                     }
 13249  2666
                     break;
 13250  
                 case 2 :
 13251  
                     // com\\googlecode\\sparkleg\\Sparql.g:397:7: verbSimple
 13252  
                     {
 13253  688
                     root_0 = (Object)adaptor.nil();
 13254  
 
 13255  
 
 13256  688
                     pushFollow(FOLLOW_verbSimple_in_verbSimpleOrPath3277);
 13257  688
                     verbSimple287=verbSimple();
 13258  
 
 13259  688
                     state._fsp--;
 13260  
 
 13261  688
                     adaptor.addChild(root_0, verbSimple287.getTree());
 13262  
 
 13263  
                     }
 13264  
                     break;
 13265  
 
 13266  
             }
 13267  3354
             retval.stop = input.LT(-1);
 13268  
 
 13269  
 
 13270  3354
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 13271  3354
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 13272  
 
 13273  
         }
 13274  0
         catch (RecognitionException re) {
 13275  0
             reportError(re);
 13276  0
             recover(input,re);
 13277  0
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 13278  
 
 13279  
         }
 13280  
 
 13281  0
         finally {
 13282  
                 // do for sure before leaving
 13283  3354
         }
 13284  3354
         return retval;
 13285  
     }
 13286  
     // $ANTLR end "verbSimpleOrPath"
 13287  
 
 13288  
 
 13289  2666
     public static class verbPath_return extends ParserRuleReturnScope {
 13290  
         Object tree;
 13291  2666
         public Object getTree() { return tree; }
 13292  
     };
 13293  
 
 13294  
 
 13295  
     // $ANTLR start "verbPath"
 13296  
     // com\\googlecode\\sparkleg\\Sparql.g:400:1: verbPath : path ;
 13297  
     public final SparqlParser.verbPath_return verbPath() throws RecognitionException {
 13298  2666
         SparqlParser.verbPath_return retval = new SparqlParser.verbPath_return();
 13299  2666
         retval.start = input.LT(1);
 13300  
 
 13301  
 
 13302  2666
         Object root_0 = null;
 13303  
 
 13304  2666
         SparqlParser.path_return path288 =null;
 13305  
 
 13306  
 
 13307  
 
 13308  
         try {
 13309  
             // com\\googlecode\\sparkleg\\Sparql.g:401:5: ( path )
 13310  
             // com\\googlecode\\sparkleg\\Sparql.g:401:7: path
 13311  
             {
 13312  2666
             root_0 = (Object)adaptor.nil();
 13313  
 
 13314  
 
 13315  2666
             pushFollow(FOLLOW_path_in_verbPath3296);
 13316  2666
             path288=path();
 13317  
 
 13318  2666
             state._fsp--;
 13319  
 
 13320  2666
             adaptor.addChild(root_0, path288.getTree());
 13321  
 
 13322  
             }
 13323  
 
 13324  2666
             retval.stop = input.LT(-1);
 13325  
 
 13326  
 
 13327  2666
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 13328  2666
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 13329  
 
 13330  
         }
 13331  0
         catch (RecognitionException re) {
 13332  0
             reportError(re);
 13333  0
             recover(input,re);
 13334  0
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 13335  
 
 13336  
         }
 13337  
 
 13338  0
         finally {
 13339  
                 // do for sure before leaving
 13340  2666
         }
 13341  2666
         return retval;
 13342  
     }
 13343  
     // $ANTLR end "verbPath"
 13344  
 
 13345  
 
 13346  688
     public static class verbSimple_return extends ParserRuleReturnScope {
 13347  
         Object tree;
 13348  688
         public Object getTree() { return tree; }
 13349  
     };
 13350  
 
 13351  
 
 13352  
     // $ANTLR start "verbSimple"
 13353  
     // com\\googlecode\\sparkleg\\Sparql.g:404:1: verbSimple : var ;
 13354  
     public final SparqlParser.verbSimple_return verbSimple() throws RecognitionException {
 13355  688
         SparqlParser.verbSimple_return retval = new SparqlParser.verbSimple_return();
 13356  688
         retval.start = input.LT(1);
 13357  
 
 13358  
 
 13359  688
         Object root_0 = null;
 13360  
 
 13361  688
         SparqlParser.var_return var289 =null;
 13362  
 
 13363  
 
 13364  
 
 13365  
         try {
 13366  
             // com\\googlecode\\sparkleg\\Sparql.g:405:5: ( var )
 13367  
             // com\\googlecode\\sparkleg\\Sparql.g:405:7: var
 13368  
             {
 13369  688
             root_0 = (Object)adaptor.nil();
 13370  
 
 13371  
 
 13372  688
             pushFollow(FOLLOW_var_in_verbSimple3317);
 13373  688
             var289=var();
 13374  
 
 13375  688
             state._fsp--;
 13376  
 
 13377  688
             adaptor.addChild(root_0, var289.getTree());
 13378  
 
 13379  
             }
 13380  
 
 13381  688
             retval.stop = input.LT(-1);
 13382  
 
 13383  
 
 13384  688
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 13385  688
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 13386  
 
 13387  
         }
 13388  0
         catch (RecognitionException re) {
 13389  0
             reportError(re);
 13390  0
             recover(input,re);
 13391  0
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 13392  
 
 13393  
         }
 13394  
 
 13395  0
         finally {
 13396  
                 // do for sure before leaving
 13397  688
         }
 13398  688
         return retval;
 13399  
     }
 13400  
     // $ANTLR end "verbSimple"
 13401  
 
 13402  
 
 13403  2686
     public static class path_return extends ParserRuleReturnScope {
 13404  
         Object tree;
 13405  2686
         public Object getTree() { return tree; }
 13406  
     };
 13407  
 
 13408  
 
 13409  
     // $ANTLR start "path"
 13410  
     // com\\googlecode\\sparkleg\\Sparql.g:408:1: path : pathSequence ( PIPE pathSequence )* -> ^( PATH ( pathSequence )+ ) ;
 13411  
     public final SparqlParser.path_return path() throws RecognitionException {
 13412  2686
         SparqlParser.path_return retval = new SparqlParser.path_return();
 13413  2686
         retval.start = input.LT(1);
 13414  
 
 13415  
 
 13416  2686
         Object root_0 = null;
 13417  
 
 13418  2686
         Token PIPE291=null;
 13419  2686
         SparqlParser.pathSequence_return pathSequence290 =null;
 13420  
 
 13421  2686
         SparqlParser.pathSequence_return pathSequence292 =null;
 13422  
 
 13423  
 
 13424  2686
         Object PIPE291_tree=null;
 13425  2686
         RewriteRuleTokenStream stream_PIPE=new RewriteRuleTokenStream(adaptor,"token PIPE");
 13426  2686
         RewriteRuleSubtreeStream stream_pathSequence=new RewriteRuleSubtreeStream(adaptor,"rule pathSequence");
 13427  
         try {
 13428  
             // com\\googlecode\\sparkleg\\Sparql.g:409:5: ( pathSequence ( PIPE pathSequence )* -> ^( PATH ( pathSequence )+ ) )
 13429  
             // com\\googlecode\\sparkleg\\Sparql.g:409:7: pathSequence ( PIPE pathSequence )*
 13430  
             {
 13431  2686
             pushFollow(FOLLOW_pathSequence_in_path3339);
 13432  2686
             pathSequence290=pathSequence();
 13433  
 
 13434  2686
             state._fsp--;
 13435  
 
 13436  2686
             stream_pathSequence.add(pathSequence290.getTree());
 13437  
 
 13438  
             // com\\googlecode\\sparkleg\\Sparql.g:409:20: ( PIPE pathSequence )*
 13439  
             loop97:
 13440  
             do {
 13441  2706
                 int alt97=2;
 13442  2706
                 switch ( input.LA(1) ) {
 13443  
                 case PIPE:
 13444  
                     {
 13445  20
                     alt97=1;
 13446  
                     }
 13447  
                     break;
 13448  
 
 13449  
                 }
 13450  
 
 13451  2706
                 switch (alt97) {
 13452  
                     case 1 :
 13453  
                         // com\\googlecode\\sparkleg\\Sparql.g:409:21: PIPE pathSequence
 13454  
                         {
 13455  20
                         PIPE291=(Token)match(input,PIPE,FOLLOW_PIPE_in_path3342);  
 13456  20
                         stream_PIPE.add(PIPE291);
 13457  
 
 13458  
 
 13459  20
                         pushFollow(FOLLOW_pathSequence_in_path3344);
 13460  20
                         pathSequence292=pathSequence();
 13461  
 
 13462  20
                         state._fsp--;
 13463  
 
 13464  20
                         stream_pathSequence.add(pathSequence292.getTree());
 13465  
 
 13466  
                         }
 13467  20
                         break;
 13468  
 
 13469  
                     default :
 13470  2686
                         break loop97;
 13471  
                 }
 13472  20
             } while (true);
 13473  
 
 13474  
 
 13475  
             // AST REWRITE
 13476  
             // elements: pathSequence
 13477  
             // token labels: 
 13478  
             // rule labels: retval
 13479  
             // token list labels: 
 13480  
             // rule list labels: 
 13481  
             // wildcard labels: 
 13482  2686
             retval.tree = root_0;
 13483  2686
             RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 13484  
 
 13485  2686
             root_0 = (Object)adaptor.nil();
 13486  
             // 409:41: -> ^( PATH ( pathSequence )+ )
 13487  
             {
 13488  
                 // com\\googlecode\\sparkleg\\Sparql.g:409:44: ^( PATH ( pathSequence )+ )
 13489  
                 {
 13490  2686
                 Object root_1 = (Object)adaptor.nil();
 13491  2686
                 root_1 = (Object)adaptor.becomeRoot(
 13492  
                 (Object)adaptor.create(PATH, "PATH")
 13493  
                 , root_1);
 13494  
 
 13495  2686
                 if ( !(stream_pathSequence.hasNext()) ) {
 13496  0
                     throw new RewriteEarlyExitException();
 13497  
                 }
 13498  5392
                 while ( stream_pathSequence.hasNext() ) {
 13499  2706
                     adaptor.addChild(root_1, stream_pathSequence.nextTree());
 13500  
 
 13501  
                 }
 13502  2686
                 stream_pathSequence.reset();
 13503  
 
 13504  2686
                 adaptor.addChild(root_0, root_1);
 13505  
                 }
 13506  
 
 13507  
             }
 13508  
 
 13509  
 
 13510  2686
             retval.tree = root_0;
 13511  
 
 13512  
             }
 13513  
 
 13514  2686
             retval.stop = input.LT(-1);
 13515  
 
 13516  
 
 13517  2686
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 13518  2686
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 13519  
 
 13520  
         }
 13521  0
         catch (RecognitionException re) {
 13522  0
             reportError(re);
 13523  0
             recover(input,re);
 13524  0
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 13525  
 
 13526  
         }
 13527  
 
 13528  0
         finally {
 13529  
                 // do for sure before leaving
 13530  2686
         }
 13531  2686
         return retval;
 13532  
     }
 13533  
     // $ANTLR end "path"
 13534  
 
 13535  
 
 13536  2706
     public static class pathSequence_return extends ParserRuleReturnScope {
 13537  
         Object tree;
 13538  2706
         public Object getTree() { return tree; }
 13539  
     };
 13540  
 
 13541  
 
 13542  
     // $ANTLR start "pathSequence"
 13543  
     // com\\googlecode\\sparkleg\\Sparql.g:412:1: pathSequence : pathEltOrInverse ( DIVIDE pathEltOrInverse )* -> ^( PATH_SEQUENCE ( pathEltOrInverse )+ ) ;
 13544  
     public final SparqlParser.pathSequence_return pathSequence() throws RecognitionException {
 13545  2706
         SparqlParser.pathSequence_return retval = new SparqlParser.pathSequence_return();
 13546  2706
         retval.start = input.LT(1);
 13547  
 
 13548  
 
 13549  2706
         Object root_0 = null;
 13550  
 
 13551  2706
         Token DIVIDE294=null;
 13552  2706
         SparqlParser.pathEltOrInverse_return pathEltOrInverse293 =null;
 13553  
 
 13554  2706
         SparqlParser.pathEltOrInverse_return pathEltOrInverse295 =null;
 13555  
 
 13556  
 
 13557  2706
         Object DIVIDE294_tree=null;
 13558  2706
         RewriteRuleTokenStream stream_DIVIDE=new RewriteRuleTokenStream(adaptor,"token DIVIDE");
 13559  2706
         RewriteRuleSubtreeStream stream_pathEltOrInverse=new RewriteRuleSubtreeStream(adaptor,"rule pathEltOrInverse");
 13560  
         try {
 13561  
             // com\\googlecode\\sparkleg\\Sparql.g:413:5: ( pathEltOrInverse ( DIVIDE pathEltOrInverse )* -> ^( PATH_SEQUENCE ( pathEltOrInverse )+ ) )
 13562  
             // com\\googlecode\\sparkleg\\Sparql.g:413:7: pathEltOrInverse ( DIVIDE pathEltOrInverse )*
 13563  
             {
 13564  2706
             pushFollow(FOLLOW_pathEltOrInverse_in_pathSequence3373);
 13565  2706
             pathEltOrInverse293=pathEltOrInverse();
 13566  
 
 13567  2706
             state._fsp--;
 13568  
 
 13569  2706
             stream_pathEltOrInverse.add(pathEltOrInverse293.getTree());
 13570  
 
 13571  
             // com\\googlecode\\sparkleg\\Sparql.g:413:24: ( DIVIDE pathEltOrInverse )*
 13572  
             loop98:
 13573  
             do {
 13574  2770
                 int alt98=2;
 13575  2770
                 switch ( input.LA(1) ) {
 13576  
                 case DIVIDE:
 13577  
                     {
 13578  64
                     alt98=1;
 13579  
                     }
 13580  
                     break;
 13581  
 
 13582  
                 }
 13583  
 
 13584  2770
                 switch (alt98) {
 13585  
                     case 1 :
 13586  
                         // com\\googlecode\\sparkleg\\Sparql.g:413:25: DIVIDE pathEltOrInverse
 13587  
                         {
 13588  64
                         DIVIDE294=(Token)match(input,DIVIDE,FOLLOW_DIVIDE_in_pathSequence3376);  
 13589  64
                         stream_DIVIDE.add(DIVIDE294);
 13590  
 
 13591  
 
 13592  64
                         pushFollow(FOLLOW_pathEltOrInverse_in_pathSequence3378);
 13593  64
                         pathEltOrInverse295=pathEltOrInverse();
 13594  
 
 13595  64
                         state._fsp--;
 13596  
 
 13597  64
                         stream_pathEltOrInverse.add(pathEltOrInverse295.getTree());
 13598  
 
 13599  
                         }
 13600  64
                         break;
 13601  
 
 13602  
                     default :
 13603  2706
                         break loop98;
 13604  
                 }
 13605  64
             } while (true);
 13606  
 
 13607  
 
 13608  
             // AST REWRITE
 13609  
             // elements: pathEltOrInverse
 13610  
             // token labels: 
 13611  
             // rule labels: retval
 13612  
             // token list labels: 
 13613  
             // rule list labels: 
 13614  
             // wildcard labels: 
 13615  2706
             retval.tree = root_0;
 13616  2706
             RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 13617  
 
 13618  2706
             root_0 = (Object)adaptor.nil();
 13619  
             // 413:51: -> ^( PATH_SEQUENCE ( pathEltOrInverse )+ )
 13620  
             {
 13621  
                 // com\\googlecode\\sparkleg\\Sparql.g:413:54: ^( PATH_SEQUENCE ( pathEltOrInverse )+ )
 13622  
                 {
 13623  2706
                 Object root_1 = (Object)adaptor.nil();
 13624  2706
                 root_1 = (Object)adaptor.becomeRoot(
 13625  
                 (Object)adaptor.create(PATH_SEQUENCE, "PATH_SEQUENCE")
 13626  
                 , root_1);
 13627  
 
 13628  2706
                 if ( !(stream_pathEltOrInverse.hasNext()) ) {
 13629  0
                     throw new RewriteEarlyExitException();
 13630  
                 }
 13631  5476
                 while ( stream_pathEltOrInverse.hasNext() ) {
 13632  2770
                     adaptor.addChild(root_1, stream_pathEltOrInverse.nextTree());
 13633  
 
 13634  
                 }
 13635  2706
                 stream_pathEltOrInverse.reset();
 13636  
 
 13637  2706
                 adaptor.addChild(root_0, root_1);
 13638  
                 }
 13639  
 
 13640  
             }
 13641  
 
 13642  
 
 13643  2706
             retval.tree = root_0;
 13644  
 
 13645  
             }
 13646  
 
 13647  2706
             retval.stop = input.LT(-1);
 13648  
 
 13649  
 
 13650  2706
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 13651  2706
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 13652  
 
 13653  
         }
 13654  0
         catch (RecognitionException re) {
 13655  0
             reportError(re);
 13656  0
             recover(input,re);
 13657  0
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 13658  
 
 13659  
         }
 13660  
 
 13661  0
         finally {
 13662  
                 // do for sure before leaving
 13663  2706
         }
 13664  2706
         return retval;
 13665  
     }
 13666  
     // $ANTLR end "pathSequence"
 13667  
 
 13668  
 
 13669  2770
     public static class pathEltOrInverse_return extends ParserRuleReturnScope {
 13670  
         Object tree;
 13671  2770
         public Object getTree() { return tree; }
 13672  
     };
 13673  
 
 13674  
 
 13675  
     // $ANTLR start "pathEltOrInverse"
 13676  
     // com\\googlecode\\sparkleg\\Sparql.g:416:1: pathEltOrInverse : ( INVERSE )? pathElt ;
 13677  
     public final SparqlParser.pathEltOrInverse_return pathEltOrInverse() throws RecognitionException {
 13678  2770
         SparqlParser.pathEltOrInverse_return retval = new SparqlParser.pathEltOrInverse_return();
 13679  2770
         retval.start = input.LT(1);
 13680  
 
 13681  
 
 13682  2770
         Object root_0 = null;
 13683  
 
 13684  2770
         Token INVERSE296=null;
 13685  2770
         SparqlParser.pathElt_return pathElt297 =null;
 13686  
 
 13687  
 
 13688  2770
         Object INVERSE296_tree=null;
 13689  
 
 13690  
         try {
 13691  
             // com\\googlecode\\sparkleg\\Sparql.g:417:5: ( ( INVERSE )? pathElt )
 13692  
             // com\\googlecode\\sparkleg\\Sparql.g:417:7: ( INVERSE )? pathElt
 13693  
             {
 13694  2770
             root_0 = (Object)adaptor.nil();
 13695  
 
 13696  
 
 13697  
             // com\\googlecode\\sparkleg\\Sparql.g:417:7: ( INVERSE )?
 13698  2770
             int alt99=2;
 13699  2770
             switch ( input.LA(1) ) {
 13700  
                 case INVERSE:
 13701  
                     {
 13702  12
                     alt99=1;
 13703  
                     }
 13704  
                     break;
 13705  
             }
 13706  
 
 13707  2770
             switch (alt99) {
 13708  
                 case 1 :
 13709  
                     // com\\googlecode\\sparkleg\\Sparql.g:417:7: INVERSE
 13710  
                     {
 13711  12
                     INVERSE296=(Token)match(input,INVERSE,FOLLOW_INVERSE_in_pathEltOrInverse3406); 
 13712  12
                     INVERSE296_tree = 
 13713  
                     (Object)adaptor.create(INVERSE296)
 13714  
                     ;
 13715  12
                     adaptor.addChild(root_0, INVERSE296_tree);
 13716  
 
 13717  
 
 13718  
                     }
 13719  
                     break;
 13720  
 
 13721  
             }
 13722  
 
 13723  
 
 13724  2770
             pushFollow(FOLLOW_pathElt_in_pathEltOrInverse3409);
 13725  2770
             pathElt297=pathElt();
 13726  
 
 13727  2770
             state._fsp--;
 13728  
 
 13729  2770
             adaptor.addChild(root_0, pathElt297.getTree());
 13730  
 
 13731  
             }
 13732  
 
 13733  2770
             retval.stop = input.LT(-1);
 13734  
 
 13735  
 
 13736  2770
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 13737  2770
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 13738  
 
 13739  
         }
 13740  0
         catch (RecognitionException re) {
 13741  0
             reportError(re);
 13742  0
             recover(input,re);
 13743  0
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 13744  
 
 13745  
         }
 13746  
 
 13747  0
         finally {
 13748  
                 // do for sure before leaving
 13749  2770
         }
 13750  2770
         return retval;
 13751  
     }
 13752  
     // $ANTLR end "pathEltOrInverse"
 13753  
 
 13754  
 
 13755  2770
     public static class pathElt_return extends ParserRuleReturnScope {
 13756  
         Object tree;
 13757  2770
         public Object getTree() { return tree; }
 13758  
     };
 13759  
 
 13760  
 
 13761  
     // $ANTLR start "pathElt"
 13762  
     // com\\googlecode\\sparkleg\\Sparql.g:420:1: pathElt : pathPrimary ( pathMod )? ;
 13763  
     public final SparqlParser.pathElt_return pathElt() throws RecognitionException {
 13764  2770
         SparqlParser.pathElt_return retval = new SparqlParser.pathElt_return();
 13765  2770
         retval.start = input.LT(1);
 13766  
 
 13767  
 
 13768  2770
         Object root_0 = null;
 13769  
 
 13770  2770
         SparqlParser.pathPrimary_return pathPrimary298 =null;
 13771  
 
 13772  2770
         SparqlParser.pathMod_return pathMod299 =null;
 13773  
 
 13774  
 
 13775  
 
 13776  
         try {
 13777  
             // com\\googlecode\\sparkleg\\Sparql.g:421:5: ( pathPrimary ( pathMod )? )
 13778  
             // com\\googlecode\\sparkleg\\Sparql.g:421:7: pathPrimary ( pathMod )?
 13779  
             {
 13780  2770
             root_0 = (Object)adaptor.nil();
 13781  
 
 13782  
 
 13783  2770
             pushFollow(FOLLOW_pathPrimary_in_pathElt3437);
 13784  2770
             pathPrimary298=pathPrimary();
 13785  
 
 13786  2770
             state._fsp--;
 13787  
 
 13788  2770
             adaptor.addChild(root_0, pathPrimary298.getTree());
 13789  
 
 13790  
             // com\\googlecode\\sparkleg\\Sparql.g:421:19: ( pathMod )?
 13791  2770
             int alt100=2;
 13792  2770
             switch ( input.LA(1) ) {
 13793  
                 case ASTERISK:
 13794  
                 case OPEN_CURLY_BRACE:
 13795  
                 case PLUS:
 13796  
                 case QUESTION_MARK:
 13797  
                     {
 13798  66
                     alt100=1;
 13799  
                     }
 13800  
                     break;
 13801  
             }
 13802  
 
 13803  2770
             switch (alt100) {
 13804  
                 case 1 :
 13805  
                     // com\\googlecode\\sparkleg\\Sparql.g:421:19: pathMod
 13806  
                     {
 13807  66
                     pushFollow(FOLLOW_pathMod_in_pathElt3439);
 13808  66
                     pathMod299=pathMod();
 13809  
 
 13810  66
                     state._fsp--;
 13811  
 
 13812  66
                     adaptor.addChild(root_0, pathMod299.getTree());
 13813  
 
 13814  
                     }
 13815  
                     break;
 13816  
 
 13817  
             }
 13818  
 
 13819  
 
 13820  
             }
 13821  
 
 13822  2770
             retval.stop = input.LT(-1);
 13823  
 
 13824  
 
 13825  2770
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 13826  2770
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 13827  
 
 13828  
         }
 13829  0
         catch (RecognitionException re) {
 13830  0
             reportError(re);
 13831  0
             recover(input,re);
 13832  0
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 13833  
 
 13834  
         }
 13835  
 
 13836  0
         finally {
 13837  
                 // do for sure before leaving
 13838  2770
         }
 13839  2770
         return retval;
 13840  
     }
 13841  
     // $ANTLR end "pathElt"
 13842  
 
 13843  
 
 13844  66
     public static class pathMod_return extends ParserRuleReturnScope {
 13845  
         Object tree;
 13846  66
         public Object getTree() { return tree; }
 13847  
     };
 13848  
 
 13849  
 
 13850  
     // $ANTLR start "pathMod"
 13851  
     // com\\googlecode\\sparkleg\\Sparql.g:424:1: pathMod : ( ASTERISK | QUESTION_MARK | PLUS | OPEN_CURLY_BRACE ( INTEGER ( COMMA ( CLOSE_CURLY_BRACE | INTEGER CLOSE_CURLY_BRACE ) | CLOSE_CURLY_BRACE ) | COMMA INTEGER CLOSE_CURLY_BRACE ) ) ;
 13852  
     public final SparqlParser.pathMod_return pathMod() throws RecognitionException {
 13853  66
         SparqlParser.pathMod_return retval = new SparqlParser.pathMod_return();
 13854  66
         retval.start = input.LT(1);
 13855  
 
 13856  
 
 13857  66
         Object root_0 = null;
 13858  
 
 13859  66
         Token ASTERISK300=null;
 13860  66
         Token QUESTION_MARK301=null;
 13861  66
         Token PLUS302=null;
 13862  66
         Token OPEN_CURLY_BRACE303=null;
 13863  66
         Token INTEGER304=null;
 13864  66
         Token COMMA305=null;
 13865  66
         Token CLOSE_CURLY_BRACE306=null;
 13866  66
         Token INTEGER307=null;
 13867  66
         Token CLOSE_CURLY_BRACE308=null;
 13868  66
         Token CLOSE_CURLY_BRACE309=null;
 13869  66
         Token COMMA310=null;
 13870  66
         Token INTEGER311=null;
 13871  66
         Token CLOSE_CURLY_BRACE312=null;
 13872  
 
 13873  66
         Object ASTERISK300_tree=null;
 13874  66
         Object QUESTION_MARK301_tree=null;
 13875  66
         Object PLUS302_tree=null;
 13876  66
         Object OPEN_CURLY_BRACE303_tree=null;
 13877  66
         Object INTEGER304_tree=null;
 13878  66
         Object COMMA305_tree=null;
 13879  66
         Object CLOSE_CURLY_BRACE306_tree=null;
 13880  66
         Object INTEGER307_tree=null;
 13881  66
         Object CLOSE_CURLY_BRACE308_tree=null;
 13882  66
         Object CLOSE_CURLY_BRACE309_tree=null;
 13883  66
         Object COMMA310_tree=null;
 13884  66
         Object INTEGER311_tree=null;
 13885  66
         Object CLOSE_CURLY_BRACE312_tree=null;
 13886  
 
 13887  
         try {
 13888  
             // com\\googlecode\\sparkleg\\Sparql.g:425:5: ( ( ASTERISK | QUESTION_MARK | PLUS | OPEN_CURLY_BRACE ( INTEGER ( COMMA ( CLOSE_CURLY_BRACE | INTEGER CLOSE_CURLY_BRACE ) | CLOSE_CURLY_BRACE ) | COMMA INTEGER CLOSE_CURLY_BRACE ) ) )
 13889  
             // com\\googlecode\\sparkleg\\Sparql.g:425:7: ( ASTERISK | QUESTION_MARK | PLUS | OPEN_CURLY_BRACE ( INTEGER ( COMMA ( CLOSE_CURLY_BRACE | INTEGER CLOSE_CURLY_BRACE ) | CLOSE_CURLY_BRACE ) | COMMA INTEGER CLOSE_CURLY_BRACE ) )
 13890  
             {
 13891  66
             root_0 = (Object)adaptor.nil();
 13892  
 
 13893  
 
 13894  
             // com\\googlecode\\sparkleg\\Sparql.g:425:7: ( ASTERISK | QUESTION_MARK | PLUS | OPEN_CURLY_BRACE ( INTEGER ( COMMA ( CLOSE_CURLY_BRACE | INTEGER CLOSE_CURLY_BRACE ) | CLOSE_CURLY_BRACE ) | COMMA INTEGER CLOSE_CURLY_BRACE ) )
 13895  66
             int alt104=4;
 13896  66
             switch ( input.LA(1) ) {
 13897  
             case ASTERISK:
 13898  
                 {
 13899  18
                 alt104=1;
 13900  
                 }
 13901  18
                 break;
 13902  
             case QUESTION_MARK:
 13903  
                 {
 13904  2
                 alt104=2;
 13905  
                 }
 13906  2
                 break;
 13907  
             case PLUS:
 13908  
                 {
 13909  16
                 alt104=3;
 13910  
                 }
 13911  16
                 break;
 13912  
             case OPEN_CURLY_BRACE:
 13913  
                 {
 13914  30
                 alt104=4;
 13915  
                 }
 13916  30
                 break;
 13917  
             default:
 13918  0
                 NoViableAltException nvae =
 13919  
                     new NoViableAltException("", 104, 0, input);
 13920  
 
 13921  0
                 throw nvae;
 13922  
 
 13923  
             }
 13924  
 
 13925  66
             switch (alt104) {
 13926  
                 case 1 :
 13927  
                     // com\\googlecode\\sparkleg\\Sparql.g:425:8: ASTERISK
 13928  
                     {
 13929  18
                     ASTERISK300=(Token)match(input,ASTERISK,FOLLOW_ASTERISK_in_pathMod3458); 
 13930  18
                     ASTERISK300_tree = 
 13931  
                     (Object)adaptor.create(ASTERISK300)
 13932  
                     ;
 13933  18
                     adaptor.addChild(root_0, ASTERISK300_tree);
 13934  
 
 13935  
 
 13936  
                     }
 13937  18
                     break;
 13938  
                 case 2 :
 13939  
                     // com\\googlecode\\sparkleg\\Sparql.g:425:19: QUESTION_MARK
 13940  
                     {
 13941  2
                     QUESTION_MARK301=(Token)match(input,QUESTION_MARK,FOLLOW_QUESTION_MARK_in_pathMod3462); 
 13942  2
                     QUESTION_MARK301_tree = 
 13943  
                     (Object)adaptor.create(QUESTION_MARK301)
 13944  
                     ;
 13945  2
                     adaptor.addChild(root_0, QUESTION_MARK301_tree);
 13946  
 
 13947  
 
 13948  
                     }
 13949  2
                     break;
 13950  
                 case 3 :
 13951  
                     // com\\googlecode\\sparkleg\\Sparql.g:425:35: PLUS
 13952  
                     {
 13953  16
                     PLUS302=(Token)match(input,PLUS,FOLLOW_PLUS_in_pathMod3466); 
 13954  16
                     PLUS302_tree = 
 13955  
                     (Object)adaptor.create(PLUS302)
 13956  
                     ;
 13957  16
                     adaptor.addChild(root_0, PLUS302_tree);
 13958  
 
 13959  
 
 13960  
                     }
 13961  16
                     break;
 13962  
                 case 4 :
 13963  
                     // com\\googlecode\\sparkleg\\Sparql.g:425:42: OPEN_CURLY_BRACE ( INTEGER ( COMMA ( CLOSE_CURLY_BRACE | INTEGER CLOSE_CURLY_BRACE ) | CLOSE_CURLY_BRACE ) | COMMA INTEGER CLOSE_CURLY_BRACE )
 13964  
                     {
 13965  30
                     OPEN_CURLY_BRACE303=(Token)match(input,OPEN_CURLY_BRACE,FOLLOW_OPEN_CURLY_BRACE_in_pathMod3470); 
 13966  30
                     OPEN_CURLY_BRACE303_tree = 
 13967  
                     (Object)adaptor.create(OPEN_CURLY_BRACE303)
 13968  
                     ;
 13969  30
                     adaptor.addChild(root_0, OPEN_CURLY_BRACE303_tree);
 13970  
 
 13971  
 
 13972  
                     // com\\googlecode\\sparkleg\\Sparql.g:425:59: ( INTEGER ( COMMA ( CLOSE_CURLY_BRACE | INTEGER CLOSE_CURLY_BRACE ) | CLOSE_CURLY_BRACE ) | COMMA INTEGER CLOSE_CURLY_BRACE )
 13973  30
                     int alt103=2;
 13974  30
                     switch ( input.LA(1) ) {
 13975  
                     case INTEGER:
 13976  
                         {
 13977  28
                         alt103=1;
 13978  
                         }
 13979  28
                         break;
 13980  
                     case COMMA:
 13981  
                         {
 13982  2
                         alt103=2;
 13983  
                         }
 13984  2
                         break;
 13985  
                     default:
 13986  0
                         NoViableAltException nvae =
 13987  
                             new NoViableAltException("", 103, 0, input);
 13988  
 
 13989  0
                         throw nvae;
 13990  
 
 13991  
                     }
 13992  
 
 13993  30
                     switch (alt103) {
 13994  
                         case 1 :
 13995  
                             // com\\googlecode\\sparkleg\\Sparql.g:425:60: INTEGER ( COMMA ( CLOSE_CURLY_BRACE | INTEGER CLOSE_CURLY_BRACE ) | CLOSE_CURLY_BRACE )
 13996  
                             {
 13997  28
                             INTEGER304=(Token)match(input,INTEGER,FOLLOW_INTEGER_in_pathMod3473); 
 13998  28
                             INTEGER304_tree = 
 13999  
                             (Object)adaptor.create(INTEGER304)
 14000  
                             ;
 14001  28
                             adaptor.addChild(root_0, INTEGER304_tree);
 14002  
 
 14003  
 
 14004  
                             // com\\googlecode\\sparkleg\\Sparql.g:425:68: ( COMMA ( CLOSE_CURLY_BRACE | INTEGER CLOSE_CURLY_BRACE ) | CLOSE_CURLY_BRACE )
 14005  28
                             int alt102=2;
 14006  28
                             switch ( input.LA(1) ) {
 14007  
                             case COMMA:
 14008  
                                 {
 14009  10
                                 alt102=1;
 14010  
                                 }
 14011  10
                                 break;
 14012  
                             case CLOSE_CURLY_BRACE:
 14013  
                                 {
 14014  18
                                 alt102=2;
 14015  
                                 }
 14016  18
                                 break;
 14017  
                             default:
 14018  0
                                 NoViableAltException nvae =
 14019  
                                     new NoViableAltException("", 102, 0, input);
 14020  
 
 14021  0
                                 throw nvae;
 14022  
 
 14023  
                             }
 14024  
 
 14025  28
                             switch (alt102) {
 14026  
                                 case 1 :
 14027  
                                     // com\\googlecode\\sparkleg\\Sparql.g:425:69: COMMA ( CLOSE_CURLY_BRACE | INTEGER CLOSE_CURLY_BRACE )
 14028  
                                     {
 14029  10
                                     COMMA305=(Token)match(input,COMMA,FOLLOW_COMMA_in_pathMod3476); 
 14030  10
                                     COMMA305_tree = 
 14031  
                                     (Object)adaptor.create(COMMA305)
 14032  
                                     ;
 14033  10
                                     adaptor.addChild(root_0, COMMA305_tree);
 14034  
 
 14035  
 
 14036  
                                     // com\\googlecode\\sparkleg\\Sparql.g:425:75: ( CLOSE_CURLY_BRACE | INTEGER CLOSE_CURLY_BRACE )
 14037  10
                                     int alt101=2;
 14038  10
                                     switch ( input.LA(1) ) {
 14039  
                                     case CLOSE_CURLY_BRACE:
 14040  
                                         {
 14041  6
                                         alt101=1;
 14042  
                                         }
 14043  6
                                         break;
 14044  
                                     case INTEGER:
 14045  
                                         {
 14046  4
                                         alt101=2;
 14047  
                                         }
 14048  4
                                         break;
 14049  
                                     default:
 14050  0
                                         NoViableAltException nvae =
 14051  
                                             new NoViableAltException("", 101, 0, input);
 14052  
 
 14053  0
                                         throw nvae;
 14054  
 
 14055  
                                     }
 14056  
 
 14057  10
                                     switch (alt101) {
 14058  
                                         case 1 :
 14059  
                                             // com\\googlecode\\sparkleg\\Sparql.g:425:76: CLOSE_CURLY_BRACE
 14060  
                                             {
 14061  6
                                             CLOSE_CURLY_BRACE306=(Token)match(input,CLOSE_CURLY_BRACE,FOLLOW_CLOSE_CURLY_BRACE_in_pathMod3479); 
 14062  6
                                             CLOSE_CURLY_BRACE306_tree = 
 14063  
                                             (Object)adaptor.create(CLOSE_CURLY_BRACE306)
 14064  
                                             ;
 14065  6
                                             adaptor.addChild(root_0, CLOSE_CURLY_BRACE306_tree);
 14066  
 
 14067  
 
 14068  
                                             }
 14069  6
                                             break;
 14070  
                                         case 2 :
 14071  
                                             // com\\googlecode\\sparkleg\\Sparql.g:425:96: INTEGER CLOSE_CURLY_BRACE
 14072  
                                             {
 14073  4
                                             INTEGER307=(Token)match(input,INTEGER,FOLLOW_INTEGER_in_pathMod3483); 
 14074  4
                                             INTEGER307_tree = 
 14075  
                                             (Object)adaptor.create(INTEGER307)
 14076  
                                             ;
 14077  4
                                             adaptor.addChild(root_0, INTEGER307_tree);
 14078  
 
 14079  
 
 14080  4
                                             CLOSE_CURLY_BRACE308=(Token)match(input,CLOSE_CURLY_BRACE,FOLLOW_CLOSE_CURLY_BRACE_in_pathMod3485); 
 14081  4
                                             CLOSE_CURLY_BRACE308_tree = 
 14082  
                                             (Object)adaptor.create(CLOSE_CURLY_BRACE308)
 14083  
                                             ;
 14084  4
                                             adaptor.addChild(root_0, CLOSE_CURLY_BRACE308_tree);
 14085  
 
 14086  
 
 14087  
                                             }
 14088  
                                             break;
 14089  
 
 14090  
                                     }
 14091  
 
 14092  
 
 14093  
                                     }
 14094  10
                                     break;
 14095  
                                 case 2 :
 14096  
                                     // com\\googlecode\\sparkleg\\Sparql.g:425:125: CLOSE_CURLY_BRACE
 14097  
                                     {
 14098  18
                                     CLOSE_CURLY_BRACE309=(Token)match(input,CLOSE_CURLY_BRACE,FOLLOW_CLOSE_CURLY_BRACE_in_pathMod3490); 
 14099  18
                                     CLOSE_CURLY_BRACE309_tree = 
 14100  
                                     (Object)adaptor.create(CLOSE_CURLY_BRACE309)
 14101  
                                     ;
 14102  18
                                     adaptor.addChild(root_0, CLOSE_CURLY_BRACE309_tree);
 14103  
 
 14104  
 
 14105  
                                     }
 14106  
                                     break;
 14107  
 
 14108  
                             }
 14109  
 
 14110  
 
 14111  
                             }
 14112  28
                             break;
 14113  
                         case 2 :
 14114  
                             // com\\googlecode\\sparkleg\\Sparql.g:425:146: COMMA INTEGER CLOSE_CURLY_BRACE
 14115  
                             {
 14116  2
                             COMMA310=(Token)match(input,COMMA,FOLLOW_COMMA_in_pathMod3495); 
 14117  2
                             COMMA310_tree = 
 14118  
                             (Object)adaptor.create(COMMA310)
 14119  
                             ;
 14120  2
                             adaptor.addChild(root_0, COMMA310_tree);
 14121  
 
 14122  
 
 14123  2
                             INTEGER311=(Token)match(input,INTEGER,FOLLOW_INTEGER_in_pathMod3497); 
 14124  2
                             INTEGER311_tree = 
 14125  
                             (Object)adaptor.create(INTEGER311)
 14126  
                             ;
 14127  2
                             adaptor.addChild(root_0, INTEGER311_tree);
 14128  
 
 14129  
 
 14130  2
                             CLOSE_CURLY_BRACE312=(Token)match(input,CLOSE_CURLY_BRACE,FOLLOW_CLOSE_CURLY_BRACE_in_pathMod3499); 
 14131  2
                             CLOSE_CURLY_BRACE312_tree = 
 14132  
                             (Object)adaptor.create(CLOSE_CURLY_BRACE312)
 14133  
                             ;
 14134  2
                             adaptor.addChild(root_0, CLOSE_CURLY_BRACE312_tree);
 14135  
 
 14136  
 
 14137  
                             }
 14138  
                             break;
 14139  
 
 14140  
                     }
 14141  
 
 14142  
 
 14143  
                     }
 14144  
                     break;
 14145  
 
 14146  
             }
 14147  
 
 14148  
 
 14149  
             }
 14150  
 
 14151  66
             retval.stop = input.LT(-1);
 14152  
 
 14153  
 
 14154  66
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 14155  66
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 14156  
 
 14157  
         }
 14158  0
         catch (RecognitionException re) {
 14159  0
             reportError(re);
 14160  0
             recover(input,re);
 14161  0
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 14162  
 
 14163  
         }
 14164  
 
 14165  0
         finally {
 14166  
                 // do for sure before leaving
 14167  66
         }
 14168  66
         return retval;
 14169  
     }
 14170  
     // $ANTLR end "pathMod"
 14171  
 
 14172  
 
 14173  2770
     public static class pathPrimary_return extends ParserRuleReturnScope {
 14174  
         Object tree;
 14175  2770
         public Object getTree() { return tree; }
 14176  
     };
 14177  
 
 14178  
 
 14179  
     // $ANTLR start "pathPrimary"
 14180  
     // com\\googlecode\\sparkleg\\Sparql.g:428:1: pathPrimary : ( iriRef -> ^( PATH_PRIMARY iriRef ) | A -> ^( PATH_PRIMARY A ) | NEGATION pathNegatedPropertySet -> ^( PATH_PRIMARY NEGATION pathNegatedPropertySet ) | OPEN_BRACE path CLOSE_BRACE -> ^( PATH_PRIMARY path ) );
 14181  
     public final SparqlParser.pathPrimary_return pathPrimary() throws RecognitionException {
 14182  2770
         SparqlParser.pathPrimary_return retval = new SparqlParser.pathPrimary_return();
 14183  2770
         retval.start = input.LT(1);
 14184  
 
 14185  
 
 14186  2770
         Object root_0 = null;
 14187  
 
 14188  2770
         Token A314=null;
 14189  2770
         Token NEGATION315=null;
 14190  2770
         Token OPEN_BRACE317=null;
 14191  2770
         Token CLOSE_BRACE319=null;
 14192  2770
         SparqlParser.iriRef_return iriRef313 =null;
 14193  
 
 14194  2770
         SparqlParser.pathNegatedPropertySet_return pathNegatedPropertySet316 =null;
 14195  
 
 14196  2770
         SparqlParser.path_return path318 =null;
 14197  
 
 14198  
 
 14199  2770
         Object A314_tree=null;
 14200  2770
         Object NEGATION315_tree=null;
 14201  2770
         Object OPEN_BRACE317_tree=null;
 14202  2770
         Object CLOSE_BRACE319_tree=null;
 14203  2770
         RewriteRuleTokenStream stream_A=new RewriteRuleTokenStream(adaptor,"token A");
 14204  2770
         RewriteRuleTokenStream stream_CLOSE_BRACE=new RewriteRuleTokenStream(adaptor,"token CLOSE_BRACE");
 14205  2770
         RewriteRuleTokenStream stream_NEGATION=new RewriteRuleTokenStream(adaptor,"token NEGATION");
 14206  2770
         RewriteRuleTokenStream stream_OPEN_BRACE=new RewriteRuleTokenStream(adaptor,"token OPEN_BRACE");
 14207  2770
         RewriteRuleSubtreeStream stream_path=new RewriteRuleSubtreeStream(adaptor,"rule path");
 14208  2770
         RewriteRuleSubtreeStream stream_iriRef=new RewriteRuleSubtreeStream(adaptor,"rule iriRef");
 14209  2770
         RewriteRuleSubtreeStream stream_pathNegatedPropertySet=new RewriteRuleSubtreeStream(adaptor,"rule pathNegatedPropertySet");
 14210  
         try {
 14211  
             // com\\googlecode\\sparkleg\\Sparql.g:429:5: ( iriRef -> ^( PATH_PRIMARY iriRef ) | A -> ^( PATH_PRIMARY A ) | NEGATION pathNegatedPropertySet -> ^( PATH_PRIMARY NEGATION pathNegatedPropertySet ) | OPEN_BRACE path CLOSE_BRACE -> ^( PATH_PRIMARY path ) )
 14212  2770
             int alt105=4;
 14213  2770
             switch ( input.LA(1) ) {
 14214  
             case IRI_REF:
 14215  
             case PNAME_LN:
 14216  
             case PNAME_NS:
 14217  
                 {
 14218  2680
                 alt105=1;
 14219  
                 }
 14220  2680
                 break;
 14221  
             case A:
 14222  
                 {
 14223  64
                 alt105=2;
 14224  
                 }
 14225  64
                 break;
 14226  
             case NEGATION:
 14227  
                 {
 14228  6
                 alt105=3;
 14229  
                 }
 14230  6
                 break;
 14231  
             case OPEN_BRACE:
 14232  
                 {
 14233  20
                 alt105=4;
 14234  
                 }
 14235  20
                 break;
 14236  
             default:
 14237  0
                 NoViableAltException nvae =
 14238  
                     new NoViableAltException("", 105, 0, input);
 14239  
 
 14240  0
                 throw nvae;
 14241  
 
 14242  
             }
 14243  
 
 14244  2770
             switch (alt105) {
 14245  
                 case 1 :
 14246  
                     // com\\googlecode\\sparkleg\\Sparql.g:429:7: iriRef
 14247  
                     {
 14248  2680
                     pushFollow(FOLLOW_iriRef_in_pathPrimary3518);
 14249  2680
                     iriRef313=iriRef();
 14250  
 
 14251  2680
                     state._fsp--;
 14252  
 
 14253  2680
                     stream_iriRef.add(iriRef313.getTree());
 14254  
 
 14255  
                     // AST REWRITE
 14256  
                     // elements: iriRef
 14257  
                     // token labels: 
 14258  
                     // rule labels: retval
 14259  
                     // token list labels: 
 14260  
                     // rule list labels: 
 14261  
                     // wildcard labels: 
 14262  2680
                     retval.tree = root_0;
 14263  2680
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 14264  
 
 14265  2680
                     root_0 = (Object)adaptor.nil();
 14266  
                     // 429:14: -> ^( PATH_PRIMARY iriRef )
 14267  
                     {
 14268  
                         // com\\googlecode\\sparkleg\\Sparql.g:429:17: ^( PATH_PRIMARY iriRef )
 14269  
                         {
 14270  2680
                         Object root_1 = (Object)adaptor.nil();
 14271  2680
                         root_1 = (Object)adaptor.becomeRoot(
 14272  
                         (Object)adaptor.create(PATH_PRIMARY, "PATH_PRIMARY")
 14273  
                         , root_1);
 14274  
 
 14275  2680
                         adaptor.addChild(root_1, stream_iriRef.nextTree());
 14276  
 
 14277  2680
                         adaptor.addChild(root_0, root_1);
 14278  
                         }
 14279  
 
 14280  
                     }
 14281  
 
 14282  
 
 14283  2680
                     retval.tree = root_0;
 14284  
 
 14285  
                     }
 14286  2680
                     break;
 14287  
                 case 2 :
 14288  
                     // com\\googlecode\\sparkleg\\Sparql.g:430:7: A
 14289  
                     {
 14290  64
                     A314=(Token)match(input,A,FOLLOW_A_in_pathPrimary3534);  
 14291  64
                     stream_A.add(A314);
 14292  
 
 14293  
 
 14294  
                     // AST REWRITE
 14295  
                     // elements: A
 14296  
                     // token labels: 
 14297  
                     // rule labels: retval
 14298  
                     // token list labels: 
 14299  
                     // rule list labels: 
 14300  
                     // wildcard labels: 
 14301  64
                     retval.tree = root_0;
 14302  64
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 14303  
 
 14304  64
                     root_0 = (Object)adaptor.nil();
 14305  
                     // 430:9: -> ^( PATH_PRIMARY A )
 14306  
                     {
 14307  
                         // com\\googlecode\\sparkleg\\Sparql.g:430:12: ^( PATH_PRIMARY A )
 14308  
                         {
 14309  64
                         Object root_1 = (Object)adaptor.nil();
 14310  64
                         root_1 = (Object)adaptor.becomeRoot(
 14311  
                         (Object)adaptor.create(PATH_PRIMARY, "PATH_PRIMARY")
 14312  
                         , root_1);
 14313  
 
 14314  64
                         adaptor.addChild(root_1, 
 14315  
                         stream_A.nextNode()
 14316  
                         );
 14317  
 
 14318  64
                         adaptor.addChild(root_0, root_1);
 14319  
                         }
 14320  
 
 14321  
                     }
 14322  
 
 14323  
 
 14324  64
                     retval.tree = root_0;
 14325  
 
 14326  
                     }
 14327  64
                     break;
 14328  
                 case 3 :
 14329  
                     // com\\googlecode\\sparkleg\\Sparql.g:431:7: NEGATION pathNegatedPropertySet
 14330  
                     {
 14331  6
                     NEGATION315=(Token)match(input,NEGATION,FOLLOW_NEGATION_in_pathPrimary3550);  
 14332  6
                     stream_NEGATION.add(NEGATION315);
 14333  
 
 14334  
 
 14335  6
                     pushFollow(FOLLOW_pathNegatedPropertySet_in_pathPrimary3552);
 14336  6
                     pathNegatedPropertySet316=pathNegatedPropertySet();
 14337  
 
 14338  6
                     state._fsp--;
 14339  
 
 14340  6
                     stream_pathNegatedPropertySet.add(pathNegatedPropertySet316.getTree());
 14341  
 
 14342  
                     // AST REWRITE
 14343  
                     // elements: pathNegatedPropertySet, NEGATION
 14344  
                     // token labels: 
 14345  
                     // rule labels: retval
 14346  
                     // token list labels: 
 14347  
                     // rule list labels: 
 14348  
                     // wildcard labels: 
 14349  6
                     retval.tree = root_0;
 14350  6
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 14351  
 
 14352  6
                     root_0 = (Object)adaptor.nil();
 14353  
                     // 431:39: -> ^( PATH_PRIMARY NEGATION pathNegatedPropertySet )
 14354  
                     {
 14355  
                         // com\\googlecode\\sparkleg\\Sparql.g:431:42: ^( PATH_PRIMARY NEGATION pathNegatedPropertySet )
 14356  
                         {
 14357  6
                         Object root_1 = (Object)adaptor.nil();
 14358  6
                         root_1 = (Object)adaptor.becomeRoot(
 14359  
                         (Object)adaptor.create(PATH_PRIMARY, "PATH_PRIMARY")
 14360  
                         , root_1);
 14361  
 
 14362  6
                         adaptor.addChild(root_1, 
 14363  
                         stream_NEGATION.nextNode()
 14364  
                         );
 14365  
 
 14366  6
                         adaptor.addChild(root_1, stream_pathNegatedPropertySet.nextTree());
 14367  
 
 14368  6
                         adaptor.addChild(root_0, root_1);
 14369  
                         }
 14370  
 
 14371  
                     }
 14372  
 
 14373  
 
 14374  6
                     retval.tree = root_0;
 14375  
 
 14376  
                     }
 14377  6
                     break;
 14378  
                 case 4 :
 14379  
                     // com\\googlecode\\sparkleg\\Sparql.g:432:7: OPEN_BRACE path CLOSE_BRACE
 14380  
                     {
 14381  20
                     OPEN_BRACE317=(Token)match(input,OPEN_BRACE,FOLLOW_OPEN_BRACE_in_pathPrimary3570);  
 14382  20
                     stream_OPEN_BRACE.add(OPEN_BRACE317);
 14383  
 
 14384  
 
 14385  20
                     pushFollow(FOLLOW_path_in_pathPrimary3572);
 14386  20
                     path318=path();
 14387  
 
 14388  20
                     state._fsp--;
 14389  
 
 14390  20
                     stream_path.add(path318.getTree());
 14391  
 
 14392  20
                     CLOSE_BRACE319=(Token)match(input,CLOSE_BRACE,FOLLOW_CLOSE_BRACE_in_pathPrimary3574);  
 14393  20
                     stream_CLOSE_BRACE.add(CLOSE_BRACE319);
 14394  
 
 14395  
 
 14396  
                     // AST REWRITE
 14397  
                     // elements: path
 14398  
                     // token labels: 
 14399  
                     // rule labels: retval
 14400  
                     // token list labels: 
 14401  
                     // rule list labels: 
 14402  
                     // wildcard labels: 
 14403  20
                     retval.tree = root_0;
 14404  20
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 14405  
 
 14406  20
                     root_0 = (Object)adaptor.nil();
 14407  
                     // 432:35: -> ^( PATH_PRIMARY path )
 14408  
                     {
 14409  
                         // com\\googlecode\\sparkleg\\Sparql.g:432:38: ^( PATH_PRIMARY path )
 14410  
                         {
 14411  20
                         Object root_1 = (Object)adaptor.nil();
 14412  20
                         root_1 = (Object)adaptor.becomeRoot(
 14413  
                         (Object)adaptor.create(PATH_PRIMARY, "PATH_PRIMARY")
 14414  
                         , root_1);
 14415  
 
 14416  20
                         adaptor.addChild(root_1, stream_path.nextTree());
 14417  
 
 14418  20
                         adaptor.addChild(root_0, root_1);
 14419  
                         }
 14420  
 
 14421  
                     }
 14422  
 
 14423  
 
 14424  20
                     retval.tree = root_0;
 14425  
 
 14426  
                     }
 14427  
                     break;
 14428  
 
 14429  
             }
 14430  2770
             retval.stop = input.LT(-1);
 14431  
 
 14432  
 
 14433  2770
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 14434  2770
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 14435  
 
 14436  
         }
 14437  0
         catch (RecognitionException re) {
 14438  0
             reportError(re);
 14439  0
             recover(input,re);
 14440  0
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 14441  
 
 14442  
         }
 14443  
 
 14444  0
         finally {
 14445  
                 // do for sure before leaving
 14446  2770
         }
 14447  2770
         return retval;
 14448  
     }
 14449  
     // $ANTLR end "pathPrimary"
 14450  
 
 14451  
 
 14452  6
     public static class pathNegatedPropertySet_return extends ParserRuleReturnScope {
 14453  
         Object tree;
 14454  6
         public Object getTree() { return tree; }
 14455  
     };
 14456  
 
 14457  
 
 14458  
     // $ANTLR start "pathNegatedPropertySet"
 14459  
     // com\\googlecode\\sparkleg\\Sparql.g:435:1: pathNegatedPropertySet : ( pathOneInPropertySet -> ^( PATH_NEGATED pathOneInPropertySet ) | OPEN_BRACE ( pathOneInPropertySet ( PIPE pathOneInPropertySet )* )? CLOSE_BRACE -> ^( PATH_NEGATED ( pathOneInPropertySet )+ ) );
 14460  
     public final SparqlParser.pathNegatedPropertySet_return pathNegatedPropertySet() throws RecognitionException {
 14461  6
         SparqlParser.pathNegatedPropertySet_return retval = new SparqlParser.pathNegatedPropertySet_return();
 14462  6
         retval.start = input.LT(1);
 14463  
 
 14464  
 
 14465  6
         Object root_0 = null;
 14466  
 
 14467  6
         Token OPEN_BRACE321=null;
 14468  6
         Token PIPE323=null;
 14469  6
         Token CLOSE_BRACE325=null;
 14470  6
         SparqlParser.pathOneInPropertySet_return pathOneInPropertySet320 =null;
 14471  
 
 14472  6
         SparqlParser.pathOneInPropertySet_return pathOneInPropertySet322 =null;
 14473  
 
 14474  6
         SparqlParser.pathOneInPropertySet_return pathOneInPropertySet324 =null;
 14475  
 
 14476  
 
 14477  6
         Object OPEN_BRACE321_tree=null;
 14478  6
         Object PIPE323_tree=null;
 14479  6
         Object CLOSE_BRACE325_tree=null;
 14480  6
         RewriteRuleTokenStream stream_PIPE=new RewriteRuleTokenStream(adaptor,"token PIPE");
 14481  6
         RewriteRuleTokenStream stream_CLOSE_BRACE=new RewriteRuleTokenStream(adaptor,"token CLOSE_BRACE");
 14482  6
         RewriteRuleTokenStream stream_OPEN_BRACE=new RewriteRuleTokenStream(adaptor,"token OPEN_BRACE");
 14483  6
         RewriteRuleSubtreeStream stream_pathOneInPropertySet=new RewriteRuleSubtreeStream(adaptor,"rule pathOneInPropertySet");
 14484  
         try {
 14485  
             // com\\googlecode\\sparkleg\\Sparql.g:436:5: ( pathOneInPropertySet -> ^( PATH_NEGATED pathOneInPropertySet ) | OPEN_BRACE ( pathOneInPropertySet ( PIPE pathOneInPropertySet )* )? CLOSE_BRACE -> ^( PATH_NEGATED ( pathOneInPropertySet )+ ) )
 14486  6
             int alt108=2;
 14487  6
             switch ( input.LA(1) ) {
 14488  
             case A:
 14489  
             case INVERSE:
 14490  
             case IRI_REF:
 14491  
             case PNAME_LN:
 14492  
             case PNAME_NS:
 14493  
                 {
 14494  0
                 alt108=1;
 14495  
                 }
 14496  0
                 break;
 14497  
             case OPEN_BRACE:
 14498  
                 {
 14499  6
                 alt108=2;
 14500  
                 }
 14501  6
                 break;
 14502  
             default:
 14503  0
                 NoViableAltException nvae =
 14504  
                     new NoViableAltException("", 108, 0, input);
 14505  
 
 14506  0
                 throw nvae;
 14507  
 
 14508  
             }
 14509  
 
 14510  6
             switch (alt108) {
 14511  
                 case 1 :
 14512  
                     // com\\googlecode\\sparkleg\\Sparql.g:436:7: pathOneInPropertySet
 14513  
                     {
 14514  0
                     pushFollow(FOLLOW_pathOneInPropertySet_in_pathNegatedPropertySet3599);
 14515  0
                     pathOneInPropertySet320=pathOneInPropertySet();
 14516  
 
 14517  0
                     state._fsp--;
 14518  
 
 14519  0
                     stream_pathOneInPropertySet.add(pathOneInPropertySet320.getTree());
 14520  
 
 14521  
                     // AST REWRITE
 14522  
                     // elements: pathOneInPropertySet
 14523  
                     // token labels: 
 14524  
                     // rule labels: retval
 14525  
                     // token list labels: 
 14526  
                     // rule list labels: 
 14527  
                     // wildcard labels: 
 14528  0
                     retval.tree = root_0;
 14529  0
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 14530  
 
 14531  0
                     root_0 = (Object)adaptor.nil();
 14532  
                     // 436:28: -> ^( PATH_NEGATED pathOneInPropertySet )
 14533  
                     {
 14534  
                         // com\\googlecode\\sparkleg\\Sparql.g:436:31: ^( PATH_NEGATED pathOneInPropertySet )
 14535  
                         {
 14536  0
                         Object root_1 = (Object)adaptor.nil();
 14537  0
                         root_1 = (Object)adaptor.becomeRoot(
 14538  
                         (Object)adaptor.create(PATH_NEGATED, "PATH_NEGATED")
 14539  
                         , root_1);
 14540  
 
 14541  0
                         adaptor.addChild(root_1, stream_pathOneInPropertySet.nextTree());
 14542  
 
 14543  0
                         adaptor.addChild(root_0, root_1);
 14544  
                         }
 14545  
 
 14546  
                     }
 14547  
 
 14548  
 
 14549  0
                     retval.tree = root_0;
 14550  
 
 14551  
                     }
 14552  0
                     break;
 14553  
                 case 2 :
 14554  
                     // com\\googlecode\\sparkleg\\Sparql.g:437:7: OPEN_BRACE ( pathOneInPropertySet ( PIPE pathOneInPropertySet )* )? CLOSE_BRACE
 14555  
                     {
 14556  6
                     OPEN_BRACE321=(Token)match(input,OPEN_BRACE,FOLLOW_OPEN_BRACE_in_pathNegatedPropertySet3615);  
 14557  6
                     stream_OPEN_BRACE.add(OPEN_BRACE321);
 14558  
 
 14559  
 
 14560  
                     // com\\googlecode\\sparkleg\\Sparql.g:437:18: ( pathOneInPropertySet ( PIPE pathOneInPropertySet )* )?
 14561  6
                     int alt107=2;
 14562  6
                     switch ( input.LA(1) ) {
 14563  
                         case A:
 14564  
                         case INVERSE:
 14565  
                         case IRI_REF:
 14566  
                         case PNAME_LN:
 14567  
                         case PNAME_NS:
 14568  
                             {
 14569  6
                             alt107=1;
 14570  
                             }
 14571  
                             break;
 14572  
                     }
 14573  
 
 14574  6
                     switch (alt107) {
 14575  
                         case 1 :
 14576  
                             // com\\googlecode\\sparkleg\\Sparql.g:437:19: pathOneInPropertySet ( PIPE pathOneInPropertySet )*
 14577  
                             {
 14578  6
                             pushFollow(FOLLOW_pathOneInPropertySet_in_pathNegatedPropertySet3618);
 14579  6
                             pathOneInPropertySet322=pathOneInPropertySet();
 14580  
 
 14581  6
                             state._fsp--;
 14582  
 
 14583  6
                             stream_pathOneInPropertySet.add(pathOneInPropertySet322.getTree());
 14584  
 
 14585  
                             // com\\googlecode\\sparkleg\\Sparql.g:437:40: ( PIPE pathOneInPropertySet )*
 14586  
                             loop106:
 14587  
                             do {
 14588  12
                                 int alt106=2;
 14589  12
                                 switch ( input.LA(1) ) {
 14590  
                                 case PIPE:
 14591  
                                     {
 14592  6
                                     alt106=1;
 14593  
                                     }
 14594  
                                     break;
 14595  
 
 14596  
                                 }
 14597  
 
 14598  12
                                 switch (alt106) {
 14599  
                                     case 1 :
 14600  
                                         // com\\googlecode\\sparkleg\\Sparql.g:437:41: PIPE pathOneInPropertySet
 14601  
                                         {
 14602  6
                                         PIPE323=(Token)match(input,PIPE,FOLLOW_PIPE_in_pathNegatedPropertySet3621);  
 14603  6
                                         stream_PIPE.add(PIPE323);
 14604  
 
 14605  
 
 14606  6
                                         pushFollow(FOLLOW_pathOneInPropertySet_in_pathNegatedPropertySet3623);
 14607  6
                                         pathOneInPropertySet324=pathOneInPropertySet();
 14608  
 
 14609  6
                                         state._fsp--;
 14610  
 
 14611  6
                                         stream_pathOneInPropertySet.add(pathOneInPropertySet324.getTree());
 14612  
 
 14613  
                                         }
 14614  6
                                         break;
 14615  
 
 14616  
                                     default :
 14617  6
                                         break loop106;
 14618  
                                 }
 14619  6
                             } while (true);
 14620  
 
 14621  
 
 14622  
                             }
 14623  
                             break;
 14624  
 
 14625  
                     }
 14626  
 
 14627  
 
 14628  6
                     CLOSE_BRACE325=(Token)match(input,CLOSE_BRACE,FOLLOW_CLOSE_BRACE_in_pathNegatedPropertySet3629);  
 14629  6
                     stream_CLOSE_BRACE.add(CLOSE_BRACE325);
 14630  
 
 14631  
 
 14632  
                     // AST REWRITE
 14633  
                     // elements: pathOneInPropertySet
 14634  
                     // token labels: 
 14635  
                     // rule labels: retval
 14636  
                     // token list labels: 
 14637  
                     // rule list labels: 
 14638  
                     // wildcard labels: 
 14639  6
                     retval.tree = root_0;
 14640  6
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 14641  
 
 14642  6
                     root_0 = (Object)adaptor.nil();
 14643  
                     // 437:83: -> ^( PATH_NEGATED ( pathOneInPropertySet )+ )
 14644  
                     {
 14645  
                         // com\\googlecode\\sparkleg\\Sparql.g:437:86: ^( PATH_NEGATED ( pathOneInPropertySet )+ )
 14646  
                         {
 14647  6
                         Object root_1 = (Object)adaptor.nil();
 14648  6
                         root_1 = (Object)adaptor.becomeRoot(
 14649  
                         (Object)adaptor.create(PATH_NEGATED, "PATH_NEGATED")
 14650  
                         , root_1);
 14651  
 
 14652  6
                         if ( !(stream_pathOneInPropertySet.hasNext()) ) {
 14653  0
                             throw new RewriteEarlyExitException();
 14654  
                         }
 14655  18
                         while ( stream_pathOneInPropertySet.hasNext() ) {
 14656  12
                             adaptor.addChild(root_1, stream_pathOneInPropertySet.nextTree());
 14657  
 
 14658  
                         }
 14659  6
                         stream_pathOneInPropertySet.reset();
 14660  
 
 14661  6
                         adaptor.addChild(root_0, root_1);
 14662  
                         }
 14663  
 
 14664  
                     }
 14665  
 
 14666  
 
 14667  6
                     retval.tree = root_0;
 14668  
 
 14669  
                     }
 14670  
                     break;
 14671  
 
 14672  
             }
 14673  6
             retval.stop = input.LT(-1);
 14674  
 
 14675  
 
 14676  6
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 14677  6
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 14678  
 
 14679  
         }
 14680  0
         catch (RecognitionException re) {
 14681  0
             reportError(re);
 14682  0
             recover(input,re);
 14683  0
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 14684  
 
 14685  
         }
 14686  
 
 14687  0
         finally {
 14688  
                 // do for sure before leaving
 14689  6
         }
 14690  6
         return retval;
 14691  
     }
 14692  
     // $ANTLR end "pathNegatedPropertySet"
 14693  
 
 14694  
 
 14695  12
     public static class pathOneInPropertySet_return extends ParserRuleReturnScope {
 14696  
         Object tree;
 14697  12
         public Object getTree() { return tree; }
 14698  
     };
 14699  
 
 14700  
 
 14701  
     // $ANTLR start "pathOneInPropertySet"
 14702  
     // com\\googlecode\\sparkleg\\Sparql.g:440:1: pathOneInPropertySet : ( INVERSE )? ( iriRef | A ) ;
 14703  
     public final SparqlParser.pathOneInPropertySet_return pathOneInPropertySet() throws RecognitionException {
 14704  12
         SparqlParser.pathOneInPropertySet_return retval = new SparqlParser.pathOneInPropertySet_return();
 14705  12
         retval.start = input.LT(1);
 14706  
 
 14707  
 
 14708  12
         Object root_0 = null;
 14709  
 
 14710  12
         Token INVERSE326=null;
 14711  12
         Token A328=null;
 14712  12
         SparqlParser.iriRef_return iriRef327 =null;
 14713  
 
 14714  
 
 14715  12
         Object INVERSE326_tree=null;
 14716  12
         Object A328_tree=null;
 14717  
 
 14718  
         try {
 14719  
             // com\\googlecode\\sparkleg\\Sparql.g:441:5: ( ( INVERSE )? ( iriRef | A ) )
 14720  
             // com\\googlecode\\sparkleg\\Sparql.g:441:7: ( INVERSE )? ( iriRef | A )
 14721  
             {
 14722  12
             root_0 = (Object)adaptor.nil();
 14723  
 
 14724  
 
 14725  
             // com\\googlecode\\sparkleg\\Sparql.g:441:7: ( INVERSE )?
 14726  12
             int alt109=2;
 14727  12
             switch ( input.LA(1) ) {
 14728  
                 case INVERSE:
 14729  
                     {
 14730  4
                     alt109=1;
 14731  
                     }
 14732  
                     break;
 14733  
             }
 14734  
 
 14735  12
             switch (alt109) {
 14736  
                 case 1 :
 14737  
                     // com\\googlecode\\sparkleg\\Sparql.g:441:7: INVERSE
 14738  
                     {
 14739  4
                     INVERSE326=(Token)match(input,INVERSE,FOLLOW_INVERSE_in_pathOneInPropertySet3658); 
 14740  4
                     INVERSE326_tree = 
 14741  
                     (Object)adaptor.create(INVERSE326)
 14742  
                     ;
 14743  4
                     adaptor.addChild(root_0, INVERSE326_tree);
 14744  
 
 14745  
 
 14746  
                     }
 14747  
                     break;
 14748  
 
 14749  
             }
 14750  
 
 14751  
 
 14752  
             // com\\googlecode\\sparkleg\\Sparql.g:441:16: ( iriRef | A )
 14753  12
             int alt110=2;
 14754  12
             switch ( input.LA(1) ) {
 14755  
             case IRI_REF:
 14756  
             case PNAME_LN:
 14757  
             case PNAME_NS:
 14758  
                 {
 14759  12
                 alt110=1;
 14760  
                 }
 14761  12
                 break;
 14762  
             case A:
 14763  
                 {
 14764  0
                 alt110=2;
 14765  
                 }
 14766  0
                 break;
 14767  
             default:
 14768  0
                 NoViableAltException nvae =
 14769  
                     new NoViableAltException("", 110, 0, input);
 14770  
 
 14771  0
                 throw nvae;
 14772  
 
 14773  
             }
 14774  
 
 14775  12
             switch (alt110) {
 14776  
                 case 1 :
 14777  
                     // com\\googlecode\\sparkleg\\Sparql.g:441:17: iriRef
 14778  
                     {
 14779  12
                     pushFollow(FOLLOW_iriRef_in_pathOneInPropertySet3662);
 14780  12
                     iriRef327=iriRef();
 14781  
 
 14782  12
                     state._fsp--;
 14783  
 
 14784  12
                     adaptor.addChild(root_0, iriRef327.getTree());
 14785  
 
 14786  
                     }
 14787  12
                     break;
 14788  
                 case 2 :
 14789  
                     // com\\googlecode\\sparkleg\\Sparql.g:441:26: A
 14790  
                     {
 14791  0
                     A328=(Token)match(input,A,FOLLOW_A_in_pathOneInPropertySet3666); 
 14792  0
                     A328_tree = 
 14793  
                     (Object)adaptor.create(A328)
 14794  
                     ;
 14795  0
                     adaptor.addChild(root_0, A328_tree);
 14796  
 
 14797  
 
 14798  
                     }
 14799  
                     break;
 14800  
 
 14801  
             }
 14802  
 
 14803  
 
 14804  
             }
 14805  
 
 14806  12
             retval.stop = input.LT(-1);
 14807  
 
 14808  
 
 14809  12
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 14810  12
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 14811  
 
 14812  
         }
 14813  0
         catch (RecognitionException re) {
 14814  0
             reportError(re);
 14815  0
             recover(input,re);
 14816  0
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 14817  
 
 14818  
         }
 14819  
 
 14820  0
         finally {
 14821  
                 // do for sure before leaving
 14822  12
         }
 14823  12
         return retval;
 14824  
     }
 14825  
     // $ANTLR end "pathOneInPropertySet"
 14826  
 
 14827  
 
 14828  66
     public static class triplesNode_return extends ParserRuleReturnScope {
 14829  
         Object tree;
 14830  66
         public Object getTree() { return tree; }
 14831  
     };
 14832  
 
 14833  
 
 14834  
     // $ANTLR start "triplesNode"
 14835  
     // com\\googlecode\\sparkleg\\Sparql.g:444:1: triplesNode : ( OPEN_BRACE ( graphNode )+ CLOSE_BRACE -> ^( COLLECTION ( graphNode )+ ) | OPEN_SQUARE_BRACKET propertyListNotEmpty CLOSE_SQUARE_BRACKET -> ^( TRIPLES_NODE propertyListNotEmpty ) );
 14836  
     public final SparqlParser.triplesNode_return triplesNode() throws RecognitionException {
 14837  66
         SparqlParser.triplesNode_return retval = new SparqlParser.triplesNode_return();
 14838  66
         retval.start = input.LT(1);
 14839  
 
 14840  
 
 14841  66
         Object root_0 = null;
 14842  
 
 14843  66
         Token OPEN_BRACE329=null;
 14844  66
         Token CLOSE_BRACE331=null;
 14845  66
         Token OPEN_SQUARE_BRACKET332=null;
 14846  66
         Token CLOSE_SQUARE_BRACKET334=null;
 14847  66
         SparqlParser.graphNode_return graphNode330 =null;
 14848  
 
 14849  66
         SparqlParser.propertyListNotEmpty_return propertyListNotEmpty333 =null;
 14850  
 
 14851  
 
 14852  66
         Object OPEN_BRACE329_tree=null;
 14853  66
         Object CLOSE_BRACE331_tree=null;
 14854  66
         Object OPEN_SQUARE_BRACKET332_tree=null;
 14855  66
         Object CLOSE_SQUARE_BRACKET334_tree=null;
 14856  66
         RewriteRuleTokenStream stream_CLOSE_BRACE=new RewriteRuleTokenStream(adaptor,"token CLOSE_BRACE");
 14857  66
         RewriteRuleTokenStream stream_OPEN_SQUARE_BRACKET=new RewriteRuleTokenStream(adaptor,"token OPEN_SQUARE_BRACKET");
 14858  66
         RewriteRuleTokenStream stream_OPEN_BRACE=new RewriteRuleTokenStream(adaptor,"token OPEN_BRACE");
 14859  66
         RewriteRuleTokenStream stream_CLOSE_SQUARE_BRACKET=new RewriteRuleTokenStream(adaptor,"token CLOSE_SQUARE_BRACKET");
 14860  66
         RewriteRuleSubtreeStream stream_graphNode=new RewriteRuleSubtreeStream(adaptor,"rule graphNode");
 14861  66
         RewriteRuleSubtreeStream stream_propertyListNotEmpty=new RewriteRuleSubtreeStream(adaptor,"rule propertyListNotEmpty");
 14862  
         try {
 14863  
             // com\\googlecode\\sparkleg\\Sparql.g:445:5: ( OPEN_BRACE ( graphNode )+ CLOSE_BRACE -> ^( COLLECTION ( graphNode )+ ) | OPEN_SQUARE_BRACKET propertyListNotEmpty CLOSE_SQUARE_BRACKET -> ^( TRIPLES_NODE propertyListNotEmpty ) )
 14864  66
             int alt112=2;
 14865  66
             switch ( input.LA(1) ) {
 14866  
             case OPEN_BRACE:
 14867  
                 {
 14868  28
                 alt112=1;
 14869  
                 }
 14870  28
                 break;
 14871  
             case OPEN_SQUARE_BRACKET:
 14872  
                 {
 14873  38
                 alt112=2;
 14874  
                 }
 14875  38
                 break;
 14876  
             default:
 14877  0
                 NoViableAltException nvae =
 14878  
                     new NoViableAltException("", 112, 0, input);
 14879  
 
 14880  0
                 throw nvae;
 14881  
 
 14882  
             }
 14883  
 
 14884  66
             switch (alt112) {
 14885  
                 case 1 :
 14886  
                     // com\\googlecode\\sparkleg\\Sparql.g:445:7: OPEN_BRACE ( graphNode )+ CLOSE_BRACE
 14887  
                     {
 14888  28
                     OPEN_BRACE329=(Token)match(input,OPEN_BRACE,FOLLOW_OPEN_BRACE_in_triplesNode3685);  
 14889  28
                     stream_OPEN_BRACE.add(OPEN_BRACE329);
 14890  
 
 14891  
 
 14892  
                     // com\\googlecode\\sparkleg\\Sparql.g:445:18: ( graphNode )+
 14893  28
                     int cnt111=0;
 14894  
                     loop111:
 14895  
                     do {
 14896  66
                         int alt111=2;
 14897  66
                         switch ( input.LA(1) ) {
 14898  
                         case BLANK_NODE_LABEL:
 14899  
                         case DECIMAL:
 14900  
                         case DECIMAL_NEGATIVE:
 14901  
                         case DECIMAL_POSITIVE:
 14902  
                         case DOUBLE:
 14903  
                         case DOUBLE_NEGATIVE:
 14904  
                         case DOUBLE_POSITIVE:
 14905  
                         case FALSE:
 14906  
                         case INTEGER:
 14907  
                         case INTEGER_NEGATIVE:
 14908  
                         case INTEGER_POSITIVE:
 14909  
                         case IRI_REF:
 14910  
                         case OPEN_BRACE:
 14911  
                         case OPEN_SQUARE_BRACKET:
 14912  
                         case PNAME_LN:
 14913  
                         case PNAME_NS:
 14914  
                         case STRING_LITERAL1:
 14915  
                         case STRING_LITERAL2:
 14916  
                         case STRING_LITERAL_LONG1:
 14917  
                         case STRING_LITERAL_LONG2:
 14918  
                         case TRUE:
 14919  
                         case VAR1:
 14920  
                         case VAR2:
 14921  
                             {
 14922  38
                             alt111=1;
 14923  
                             }
 14924  
                             break;
 14925  
 
 14926  
                         }
 14927  
 
 14928  66
                         switch (alt111) {
 14929  
                             case 1 :
 14930  
                                 // com\\googlecode\\sparkleg\\Sparql.g:445:18: graphNode
 14931  
                                 {
 14932  38
                                 pushFollow(FOLLOW_graphNode_in_triplesNode3687);
 14933  38
                                 graphNode330=graphNode();
 14934  
 
 14935  38
                                 state._fsp--;
 14936  
 
 14937  38
                                 stream_graphNode.add(graphNode330.getTree());
 14938  
 
 14939  
                                 }
 14940  38
                                 break;
 14941  
 
 14942  
                             default :
 14943  28
                                 if ( cnt111 >= 1 ) break loop111;
 14944  0
                                 EarlyExitException eee =
 14945  
                                     new EarlyExitException(111, input);
 14946  0
                                 throw eee;
 14947  
                         }
 14948  38
                         cnt111++;
 14949  38
                     } while (true);
 14950  
 
 14951  
 
 14952  28
                     CLOSE_BRACE331=(Token)match(input,CLOSE_BRACE,FOLLOW_CLOSE_BRACE_in_triplesNode3690);  
 14953  28
                     stream_CLOSE_BRACE.add(CLOSE_BRACE331);
 14954  
 
 14955  
 
 14956  
                     // AST REWRITE
 14957  
                     // elements: graphNode
 14958  
                     // token labels: 
 14959  
                     // rule labels: retval
 14960  
                     // token list labels: 
 14961  
                     // rule list labels: 
 14962  
                     // wildcard labels: 
 14963  28
                     retval.tree = root_0;
 14964  28
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 14965  
 
 14966  28
                     root_0 = (Object)adaptor.nil();
 14967  
                     // 445:41: -> ^( COLLECTION ( graphNode )+ )
 14968  
                     {
 14969  
                         // com\\googlecode\\sparkleg\\Sparql.g:445:44: ^( COLLECTION ( graphNode )+ )
 14970  
                         {
 14971  28
                         Object root_1 = (Object)adaptor.nil();
 14972  28
                         root_1 = (Object)adaptor.becomeRoot(
 14973  
                         (Object)adaptor.create(COLLECTION, "COLLECTION")
 14974  
                         , root_1);
 14975  
 
 14976  28
                         if ( !(stream_graphNode.hasNext()) ) {
 14977  0
                             throw new RewriteEarlyExitException();
 14978  
                         }
 14979  66
                         while ( stream_graphNode.hasNext() ) {
 14980  38
                             adaptor.addChild(root_1, stream_graphNode.nextTree());
 14981  
 
 14982  
                         }
 14983  28
                         stream_graphNode.reset();
 14984  
 
 14985  28
                         adaptor.addChild(root_0, root_1);
 14986  
                         }
 14987  
 
 14988  
                     }
 14989  
 
 14990  
 
 14991  28
                     retval.tree = root_0;
 14992  
 
 14993  
                     }
 14994  28
                     break;
 14995  
                 case 2 :
 14996  
                     // com\\googlecode\\sparkleg\\Sparql.g:446:7: OPEN_SQUARE_BRACKET propertyListNotEmpty CLOSE_SQUARE_BRACKET
 14997  
                     {
 14998  38
                     OPEN_SQUARE_BRACKET332=(Token)match(input,OPEN_SQUARE_BRACKET,FOLLOW_OPEN_SQUARE_BRACKET_in_triplesNode3707);  
 14999  38
                     stream_OPEN_SQUARE_BRACKET.add(OPEN_SQUARE_BRACKET332);
 15000  
 
 15001  
 
 15002  38
                     pushFollow(FOLLOW_propertyListNotEmpty_in_triplesNode3709);
 15003  38
                     propertyListNotEmpty333=propertyListNotEmpty();
 15004  
 
 15005  38
                     state._fsp--;
 15006  
 
 15007  38
                     stream_propertyListNotEmpty.add(propertyListNotEmpty333.getTree());
 15008  
 
 15009  38
                     CLOSE_SQUARE_BRACKET334=(Token)match(input,CLOSE_SQUARE_BRACKET,FOLLOW_CLOSE_SQUARE_BRACKET_in_triplesNode3711);  
 15010  38
                     stream_CLOSE_SQUARE_BRACKET.add(CLOSE_SQUARE_BRACKET334);
 15011  
 
 15012  
 
 15013  
                     // AST REWRITE
 15014  
                     // elements: propertyListNotEmpty
 15015  
                     // token labels: 
 15016  
                     // rule labels: retval
 15017  
                     // token list labels: 
 15018  
                     // rule list labels: 
 15019  
                     // wildcard labels: 
 15020  38
                     retval.tree = root_0;
 15021  38
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 15022  
 
 15023  38
                     root_0 = (Object)adaptor.nil();
 15024  
                     // 446:69: -> ^( TRIPLES_NODE propertyListNotEmpty )
 15025  
                     {
 15026  
                         // com\\googlecode\\sparkleg\\Sparql.g:446:72: ^( TRIPLES_NODE propertyListNotEmpty )
 15027  
                         {
 15028  38
                         Object root_1 = (Object)adaptor.nil();
 15029  38
                         root_1 = (Object)adaptor.becomeRoot(
 15030  
                         (Object)adaptor.create(TRIPLES_NODE, "TRIPLES_NODE")
 15031  
                         , root_1);
 15032  
 
 15033  38
                         adaptor.addChild(root_1, stream_propertyListNotEmpty.nextTree());
 15034  
 
 15035  38
                         adaptor.addChild(root_0, root_1);
 15036  
                         }
 15037  
 
 15038  
                     }
 15039  
 
 15040  
 
 15041  38
                     retval.tree = root_0;
 15042  
 
 15043  
                     }
 15044  
                     break;
 15045  
 
 15046  
             }
 15047  66
             retval.stop = input.LT(-1);
 15048  
 
 15049  
 
 15050  66
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 15051  66
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 15052  
 
 15053  
         }
 15054  0
         catch (RecognitionException re) {
 15055  0
             reportError(re);
 15056  0
             recover(input,re);
 15057  0
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 15058  
 
 15059  
         }
 15060  
 
 15061  0
         finally {
 15062  
                 // do for sure before leaving
 15063  66
         }
 15064  66
         return retval;
 15065  
     }
 15066  
     // $ANTLR end "triplesNode"
 15067  
 
 15068  
 
 15069  3396
     public static class graphNode_return extends ParserRuleReturnScope {
 15070  
         Object tree;
 15071  3396
         public Object getTree() { return tree; }
 15072  
     };
 15073  
 
 15074  
 
 15075  
     // $ANTLR start "graphNode"
 15076  
     // com\\googlecode\\sparkleg\\Sparql.g:449:1: graphNode : ( varOrTerm | triplesNode );
 15077  
     public final SparqlParser.graphNode_return graphNode() throws RecognitionException {
 15078  3396
         SparqlParser.graphNode_return retval = new SparqlParser.graphNode_return();
 15079  3396
         retval.start = input.LT(1);
 15080  
 
 15081  
 
 15082  3396
         Object root_0 = null;
 15083  
 
 15084  3396
         SparqlParser.varOrTerm_return varOrTerm335 =null;
 15085  
 
 15086  3396
         SparqlParser.triplesNode_return triplesNode336 =null;
 15087  
 
 15088  
 
 15089  
 
 15090  
         try {
 15091  
             // com\\googlecode\\sparkleg\\Sparql.g:450:5: ( varOrTerm | triplesNode )
 15092  3396
             int alt113=2;
 15093  3396
             switch ( input.LA(1) ) {
 15094  
             case BLANK_NODE_LABEL:
 15095  
             case DECIMAL:
 15096  
             case DECIMAL_NEGATIVE:
 15097  
             case DECIMAL_POSITIVE:
 15098  
             case DOUBLE:
 15099  
             case DOUBLE_NEGATIVE:
 15100  
             case DOUBLE_POSITIVE:
 15101  
             case FALSE:
 15102  
             case INTEGER:
 15103  
             case INTEGER_NEGATIVE:
 15104  
             case INTEGER_POSITIVE:
 15105  
             case IRI_REF:
 15106  
             case PNAME_LN:
 15107  
             case PNAME_NS:
 15108  
             case STRING_LITERAL1:
 15109  
             case STRING_LITERAL2:
 15110  
             case STRING_LITERAL_LONG1:
 15111  
             case STRING_LITERAL_LONG2:
 15112  
             case TRUE:
 15113  
             case VAR1:
 15114  
             case VAR2:
 15115  
                 {
 15116  3336
                 alt113=1;
 15117  
                 }
 15118  3336
                 break;
 15119  
             case OPEN_SQUARE_BRACKET:
 15120  
                 {
 15121  44
                 switch ( input.LA(2) ) {
 15122  
                 case CLOSE_SQUARE_BRACKET:
 15123  
                     {
 15124  22
                     alt113=1;
 15125  
                     }
 15126  22
                     break;
 15127  
                 case A:
 15128  
                 case INVERSE:
 15129  
                 case IRI_REF:
 15130  
                 case NEGATION:
 15131  
                 case OPEN_BRACE:
 15132  
                 case PNAME_LN:
 15133  
                 case PNAME_NS:
 15134  
                 case VAR1:
 15135  
                 case VAR2:
 15136  
                     {
 15137  22
                     alt113=2;
 15138  
                     }
 15139  22
                     break;
 15140  
                 default:
 15141  0
                     NoViableAltException nvae =
 15142  
                         new NoViableAltException("", 113, 2, input);
 15143  
 
 15144  0
                     throw nvae;
 15145  
 
 15146  
                 }
 15147  
 
 15148  
                 }
 15149  44
                 break;
 15150  
             case OPEN_BRACE:
 15151  
                 {
 15152  16
                 switch ( input.LA(2) ) {
 15153  
                 case CLOSE_BRACE:
 15154  
                     {
 15155  4
                     alt113=1;
 15156  
                     }
 15157  4
                     break;
 15158  
                 case BLANK_NODE_LABEL:
 15159  
                 case DECIMAL:
 15160  
                 case DECIMAL_NEGATIVE:
 15161  
                 case DECIMAL_POSITIVE:
 15162  
                 case DOUBLE:
 15163  
                 case DOUBLE_NEGATIVE:
 15164  
                 case DOUBLE_POSITIVE:
 15165  
                 case FALSE:
 15166  
                 case INTEGER:
 15167  
                 case INTEGER_NEGATIVE:
 15168  
                 case INTEGER_POSITIVE:
 15169  
                 case IRI_REF:
 15170  
                 case OPEN_BRACE:
 15171  
                 case OPEN_SQUARE_BRACKET:
 15172  
                 case PNAME_LN:
 15173  
                 case PNAME_NS:
 15174  
                 case STRING_LITERAL1:
 15175  
                 case STRING_LITERAL2:
 15176  
                 case STRING_LITERAL_LONG1:
 15177  
                 case STRING_LITERAL_LONG2:
 15178  
                 case TRUE:
 15179  
                 case VAR1:
 15180  
                 case VAR2:
 15181  
                     {
 15182  12
                     alt113=2;
 15183  
                     }
 15184  12
                     break;
 15185  
                 default:
 15186  0
                     NoViableAltException nvae =
 15187  
                         new NoViableAltException("", 113, 3, input);
 15188  
 
 15189  0
                     throw nvae;
 15190  
 
 15191  
                 }
 15192  
 
 15193  
                 }
 15194  16
                 break;
 15195  
             default:
 15196  0
                 NoViableAltException nvae =
 15197  
                     new NoViableAltException("", 113, 0, input);
 15198  
 
 15199  0
                 throw nvae;
 15200  
 
 15201  
             }
 15202  
 
 15203  3396
             switch (alt113) {
 15204  
                 case 1 :
 15205  
                     // com\\googlecode\\sparkleg\\Sparql.g:450:7: varOrTerm
 15206  
                     {
 15207  3362
                     root_0 = (Object)adaptor.nil();
 15208  
 
 15209  
 
 15210  3362
                     pushFollow(FOLLOW_varOrTerm_in_graphNode3736);
 15211  3362
                     varOrTerm335=varOrTerm();
 15212  
 
 15213  3362
                     state._fsp--;
 15214  
 
 15215  3362
                     adaptor.addChild(root_0, varOrTerm335.getTree());
 15216  
 
 15217  
                     }
 15218  3362
                     break;
 15219  
                 case 2 :
 15220  
                     // com\\googlecode\\sparkleg\\Sparql.g:450:19: triplesNode
 15221  
                     {
 15222  34
                     root_0 = (Object)adaptor.nil();
 15223  
 
 15224  
 
 15225  34
                     pushFollow(FOLLOW_triplesNode_in_graphNode3740);
 15226  34
                     triplesNode336=triplesNode();
 15227  
 
 15228  34
                     state._fsp--;
 15229  
 
 15230  34
                     adaptor.addChild(root_0, triplesNode336.getTree());
 15231  
 
 15232  
                     }
 15233  
                     break;
 15234  
 
 15235  
             }
 15236  3396
             retval.stop = input.LT(-1);
 15237  
 
 15238  
 
 15239  3396
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 15240  3396
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 15241  
 
 15242  
         }
 15243  0
         catch (RecognitionException re) {
 15244  0
             reportError(re);
 15245  0
             recover(input,re);
 15246  0
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 15247  
 
 15248  
         }
 15249  
 
 15250  0
         finally {
 15251  
                 // do for sure before leaving
 15252  3396
         }
 15253  3396
         return retval;
 15254  
     }
 15255  
     // $ANTLR end "graphNode"
 15256  
 
 15257  
 
 15258  6438
     public static class varOrTerm_return extends ParserRuleReturnScope {
 15259  
         Object tree;
 15260  6438
         public Object getTree() { return tree; }
 15261  
     };
 15262  
 
 15263  
 
 15264  
     // $ANTLR start "varOrTerm"
 15265  
     // com\\googlecode\\sparkleg\\Sparql.g:453:1: varOrTerm : ( var | graphTerm );
 15266  
     public final SparqlParser.varOrTerm_return varOrTerm() throws RecognitionException {
 15267  6438
         SparqlParser.varOrTerm_return retval = new SparqlParser.varOrTerm_return();
 15268  6438
         retval.start = input.LT(1);
 15269  
 
 15270  
 
 15271  6438
         Object root_0 = null;
 15272  
 
 15273  6438
         SparqlParser.var_return var337 =null;
 15274  
 
 15275  6438
         SparqlParser.graphTerm_return graphTerm338 =null;
 15276  
 
 15277  
 
 15278  
 
 15279  
         try {
 15280  
             // com\\googlecode\\sparkleg\\Sparql.g:454:5: ( var | graphTerm )
 15281  6438
             int alt114=2;
 15282  6438
             switch ( input.LA(1) ) {
 15283  
             case VAR1:
 15284  
             case VAR2:
 15285  
                 {
 15286  4922
                 alt114=1;
 15287  
                 }
 15288  4922
                 break;
 15289  
             case BLANK_NODE_LABEL:
 15290  
             case DECIMAL:
 15291  
             case DECIMAL_NEGATIVE:
 15292  
             case DECIMAL_POSITIVE:
 15293  
             case DOUBLE:
 15294  
             case DOUBLE_NEGATIVE:
 15295  
             case DOUBLE_POSITIVE:
 15296  
             case FALSE:
 15297  
             case INTEGER:
 15298  
             case INTEGER_NEGATIVE:
 15299  
             case INTEGER_POSITIVE:
 15300  
             case IRI_REF:
 15301  
             case OPEN_BRACE:
 15302  
             case OPEN_SQUARE_BRACKET:
 15303  
             case PNAME_LN:
 15304  
             case PNAME_NS:
 15305  
             case STRING_LITERAL1:
 15306  
             case STRING_LITERAL2:
 15307  
             case STRING_LITERAL_LONG1:
 15308  
             case STRING_LITERAL_LONG2:
 15309  
             case TRUE:
 15310  
                 {
 15311  1516
                 alt114=2;
 15312  
                 }
 15313  1516
                 break;
 15314  
             default:
 15315  0
                 NoViableAltException nvae =
 15316  
                     new NoViableAltException("", 114, 0, input);
 15317  
 
 15318  0
                 throw nvae;
 15319  
 
 15320  
             }
 15321  
 
 15322  6438
             switch (alt114) {
 15323  
                 case 1 :
 15324  
                     // com\\googlecode\\sparkleg\\Sparql.g:454:7: var
 15325  
                     {
 15326  4922
                     root_0 = (Object)adaptor.nil();
 15327  
 
 15328  
 
 15329  4922
                     pushFollow(FOLLOW_var_in_varOrTerm3757);
 15330  4922
                     var337=var();
 15331  
 
 15332  4922
                     state._fsp--;
 15333  
 
 15334  4922
                     adaptor.addChild(root_0, var337.getTree());
 15335  
 
 15336  
                     }
 15337  4922
                     break;
 15338  
                 case 2 :
 15339  
                     // com\\googlecode\\sparkleg\\Sparql.g:455:7: graphTerm
 15340  
                     {
 15341  1516
                     root_0 = (Object)adaptor.nil();
 15342  
 
 15343  
 
 15344  1516
                     pushFollow(FOLLOW_graphTerm_in_varOrTerm3765);
 15345  1516
                     graphTerm338=graphTerm();
 15346  
 
 15347  1516
                     state._fsp--;
 15348  
 
 15349  1516
                     adaptor.addChild(root_0, graphTerm338.getTree());
 15350  
 
 15351  
                     }
 15352  
                     break;
 15353  
 
 15354  
             }
 15355  6438
             retval.stop = input.LT(-1);
 15356  
 
 15357  
 
 15358  6438
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 15359  6438
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 15360  
 
 15361  
         }
 15362  0
         catch (RecognitionException re) {
 15363  0
             reportError(re);
 15364  0
             recover(input,re);
 15365  0
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 15366  
 
 15367  
         }
 15368  
 
 15369  0
         finally {
 15370  
                 // do for sure before leaving
 15371  6438
         }
 15372  6438
         return retval;
 15373  
     }
 15374  
     // $ANTLR end "varOrTerm"
 15375  
 
 15376  
 
 15377  254
     public static class varOrIRIref_return extends ParserRuleReturnScope {
 15378  
         Object tree;
 15379  296
         public Object getTree() { return tree; }
 15380  
     };
 15381  
 
 15382  
 
 15383  
     // $ANTLR start "varOrIRIref"
 15384  
     // com\\googlecode\\sparkleg\\Sparql.g:458:1: varOrIRIref : ( var | iriRef );
 15385  
     public final SparqlParser.varOrIRIref_return varOrIRIref() throws RecognitionException {
 15386  254
         SparqlParser.varOrIRIref_return retval = new SparqlParser.varOrIRIref_return();
 15387  254
         retval.start = input.LT(1);
 15388  
 
 15389  
 
 15390  254
         Object root_0 = null;
 15391  
 
 15392  254
         SparqlParser.var_return var339 =null;
 15393  
 
 15394  254
         SparqlParser.iriRef_return iriRef340 =null;
 15395  
 
 15396  
 
 15397  
 
 15398  
         try {
 15399  
             // com\\googlecode\\sparkleg\\Sparql.g:459:5: ( var | iriRef )
 15400  254
             int alt115=2;
 15401  254
             switch ( input.LA(1) ) {
 15402  
             case VAR1:
 15403  
             case VAR2:
 15404  
                 {
 15405  144
                 alt115=1;
 15406  
                 }
 15407  144
                 break;
 15408  
             case IRI_REF:
 15409  
             case PNAME_LN:
 15410  
             case PNAME_NS:
 15411  
                 {
 15412  110
                 alt115=2;
 15413  
                 }
 15414  110
                 break;
 15415  
             default:
 15416  0
                 NoViableAltException nvae =
 15417  
                     new NoViableAltException("", 115, 0, input);
 15418  
 
 15419  0
                 throw nvae;
 15420  
 
 15421  
             }
 15422  
 
 15423  254
             switch (alt115) {
 15424  
                 case 1 :
 15425  
                     // com\\googlecode\\sparkleg\\Sparql.g:459:7: var
 15426  
                     {
 15427  144
                     root_0 = (Object)adaptor.nil();
 15428  
 
 15429  
 
 15430  144
                     pushFollow(FOLLOW_var_in_varOrIRIref3782);
 15431  144
                     var339=var();
 15432  
 
 15433  144
                     state._fsp--;
 15434  
 
 15435  144
                     adaptor.addChild(root_0, var339.getTree());
 15436  
 
 15437  
                     }
 15438  144
                     break;
 15439  
                 case 2 :
 15440  
                     // com\\googlecode\\sparkleg\\Sparql.g:459:13: iriRef
 15441  
                     {
 15442  110
                     root_0 = (Object)adaptor.nil();
 15443  
 
 15444  
 
 15445  110
                     pushFollow(FOLLOW_iriRef_in_varOrIRIref3786);
 15446  110
                     iriRef340=iriRef();
 15447  
 
 15448  110
                     state._fsp--;
 15449  
 
 15450  110
                     adaptor.addChild(root_0, iriRef340.getTree());
 15451  
 
 15452  
                     }
 15453  
                     break;
 15454  
 
 15455  
             }
 15456  254
             retval.stop = input.LT(-1);
 15457  
 
 15458  
 
 15459  254
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 15460  254
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 15461  
 
 15462  
         }
 15463  0
         catch (RecognitionException re) {
 15464  0
             reportError(re);
 15465  0
             recover(input,re);
 15466  0
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 15467  
 
 15468  
         }
 15469  
 
 15470  0
         finally {
 15471  
                 // do for sure before leaving
 15472  254
         }
 15473  254
         return retval;
 15474  
     }
 15475  
     // $ANTLR end "varOrIRIref"
 15476  
 
 15477  
 
 15478  8906
     public static class var_return extends ParserRuleReturnScope {
 15479  
         Object tree;
 15480  8906
         public Object getTree() { return tree; }
 15481  
     };
 15482  
 
 15483  
 
 15484  
     // $ANTLR start "var"
 15485  
     // com\\googlecode\\sparkleg\\Sparql.g:462:1: var : ( VAR1 | VAR2 );
 15486  
     public final SparqlParser.var_return var() throws RecognitionException {
 15487  8906
         SparqlParser.var_return retval = new SparqlParser.var_return();
 15488  8906
         retval.start = input.LT(1);
 15489  
 
 15490  
 
 15491  8906
         Object root_0 = null;
 15492  
 
 15493  8906
         Token set341=null;
 15494  
 
 15495  8906
         Object set341_tree=null;
 15496  
 
 15497  
         try {
 15498  
             // com\\googlecode\\sparkleg\\Sparql.g:463:5: ( VAR1 | VAR2 )
 15499  
             // com\\googlecode\\sparkleg\\Sparql.g:
 15500  
             {
 15501  8906
             root_0 = (Object)adaptor.nil();
 15502  
 
 15503  
 
 15504  8906
             set341=(Token)input.LT(1);
 15505  
 
 15506  8906
             if ( (input.LA(1) >= VAR1 && input.LA(1) <= VAR2) ) {
 15507  8906
                 input.consume();
 15508  8906
                 adaptor.addChild(root_0, 
 15509  
                 (Object)adaptor.create(set341)
 15510  
                 );
 15511  8906
                 state.errorRecovery=false;
 15512  
             }
 15513  
             else {
 15514  0
                 MismatchedSetException mse = new MismatchedSetException(null,input);
 15515  0
                 throw mse;
 15516  
             }
 15517  
 
 15518  
 
 15519  
             }
 15520  
 
 15521  8906
             retval.stop = input.LT(-1);
 15522  
 
 15523  
 
 15524  8906
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 15525  8906
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 15526  
 
 15527  
         }
 15528  0
         catch (RecognitionException re) {
 15529  0
             reportError(re);
 15530  0
             recover(input,re);
 15531  0
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 15532  
 
 15533  
         }
 15534  
 
 15535  0
         finally {
 15536  
                 // do for sure before leaving
 15537  8906
         }
 15538  8906
         return retval;
 15539  
     }
 15540  
     // $ANTLR end "var"
 15541  
 
 15542  
 
 15543  1516
     public static class graphTerm_return extends ParserRuleReturnScope {
 15544  
         Object tree;
 15545  1516
         public Object getTree() { return tree; }
 15546  
     };
 15547  
 
 15548  
 
 15549  
     // $ANTLR start "graphTerm"
 15550  
     // com\\googlecode\\sparkleg\\Sparql.g:466:1: graphTerm : ( iriRef | rdfLiteral | numericLiteral | booleanLiteral | blankNode | nil );
 15551  
     public final SparqlParser.graphTerm_return graphTerm() throws RecognitionException {
 15552  1516
         SparqlParser.graphTerm_return retval = new SparqlParser.graphTerm_return();
 15553  1516
         retval.start = input.LT(1);
 15554  
 
 15555  
 
 15556  1516
         Object root_0 = null;
 15557  
 
 15558  1516
         SparqlParser.iriRef_return iriRef342 =null;
 15559  
 
 15560  1516
         SparqlParser.rdfLiteral_return rdfLiteral343 =null;
 15561  
 
 15562  1516
         SparqlParser.numericLiteral_return numericLiteral344 =null;
 15563  
 
 15564  1516
         SparqlParser.booleanLiteral_return booleanLiteral345 =null;
 15565  
 
 15566  1516
         SparqlParser.blankNode_return blankNode346 =null;
 15567  
 
 15568  1516
         SparqlParser.nil_return nil347 =null;
 15569  
 
 15570  
 
 15571  
 
 15572  
         try {
 15573  
             // com\\googlecode\\sparkleg\\Sparql.g:467:5: ( iriRef | rdfLiteral | numericLiteral | booleanLiteral | blankNode | nil )
 15574  1516
             int alt116=6;
 15575  1516
             switch ( input.LA(1) ) {
 15576  
             case IRI_REF:
 15577  
             case PNAME_LN:
 15578  
             case PNAME_NS:
 15579  
                 {
 15580  1060
                 alt116=1;
 15581  
                 }
 15582  1060
                 break;
 15583  
             case STRING_LITERAL1:
 15584  
             case STRING_LITERAL2:
 15585  
             case STRING_LITERAL_LONG1:
 15586  
             case STRING_LITERAL_LONG2:
 15587  
                 {
 15588  156
                 alt116=2;
 15589  
                 }
 15590  156
                 break;
 15591  
             case DECIMAL:
 15592  
             case DECIMAL_NEGATIVE:
 15593  
             case DECIMAL_POSITIVE:
 15594  
             case DOUBLE:
 15595  
             case DOUBLE_NEGATIVE:
 15596  
             case DOUBLE_POSITIVE:
 15597  
             case INTEGER:
 15598  
             case INTEGER_NEGATIVE:
 15599  
             case INTEGER_POSITIVE:
 15600  
                 {
 15601  94
                 alt116=3;
 15602  
                 }
 15603  94
                 break;
 15604  
             case FALSE:
 15605  
             case TRUE:
 15606  
                 {
 15607  4
                 alt116=4;
 15608  
                 }
 15609  4
                 break;
 15610  
             case BLANK_NODE_LABEL:
 15611  
             case OPEN_SQUARE_BRACKET:
 15612  
                 {
 15613  192
                 alt116=5;
 15614  
                 }
 15615  192
                 break;
 15616  
             case OPEN_BRACE:
 15617  
                 {
 15618  10
                 alt116=6;
 15619  
                 }
 15620  10
                 break;
 15621  
             default:
 15622  0
                 NoViableAltException nvae =
 15623  
                     new NoViableAltException("", 116, 0, input);
 15624  
 
 15625  0
                 throw nvae;
 15626  
 
 15627  
             }
 15628  
 
 15629  1516
             switch (alt116) {
 15630  
                 case 1 :
 15631  
                     // com\\googlecode\\sparkleg\\Sparql.g:467:7: iriRef
 15632  
                     {
 15633  1060
                     root_0 = (Object)adaptor.nil();
 15634  
 
 15635  
 
 15636  1060
                     pushFollow(FOLLOW_iriRef_in_graphTerm3824);
 15637  1060
                     iriRef342=iriRef();
 15638  
 
 15639  1060
                     state._fsp--;
 15640  
 
 15641  1060
                     adaptor.addChild(root_0, iriRef342.getTree());
 15642  
 
 15643  
                     }
 15644  1060
                     break;
 15645  
                 case 2 :
 15646  
                     // com\\googlecode\\sparkleg\\Sparql.g:468:7: rdfLiteral
 15647  
                     {
 15648  156
                     root_0 = (Object)adaptor.nil();
 15649  
 
 15650  
 
 15651  156
                     pushFollow(FOLLOW_rdfLiteral_in_graphTerm3832);
 15652  156
                     rdfLiteral343=rdfLiteral();
 15653  
 
 15654  156
                     state._fsp--;
 15655  
 
 15656  156
                     adaptor.addChild(root_0, rdfLiteral343.getTree());
 15657  
 
 15658  
                     }
 15659  156
                     break;
 15660  
                 case 3 :
 15661  
                     // com\\googlecode\\sparkleg\\Sparql.g:469:7: numericLiteral
 15662  
                     {
 15663  94
                     root_0 = (Object)adaptor.nil();
 15664  
 
 15665  
 
 15666  94
                     pushFollow(FOLLOW_numericLiteral_in_graphTerm3840);
 15667  94
                     numericLiteral344=numericLiteral();
 15668  
 
 15669  94
                     state._fsp--;
 15670  
 
 15671  94
                     adaptor.addChild(root_0, numericLiteral344.getTree());
 15672  
 
 15673  
                     }
 15674  94
                     break;
 15675  
                 case 4 :
 15676  
                     // com\\googlecode\\sparkleg\\Sparql.g:470:7: booleanLiteral
 15677  
                     {
 15678  4
                     root_0 = (Object)adaptor.nil();
 15679  
 
 15680  
 
 15681  4
                     pushFollow(FOLLOW_booleanLiteral_in_graphTerm3848);
 15682  4
                     booleanLiteral345=booleanLiteral();
 15683  
 
 15684  4
                     state._fsp--;
 15685  
 
 15686  4
                     adaptor.addChild(root_0, booleanLiteral345.getTree());
 15687  
 
 15688  
                     }
 15689  4
                     break;
 15690  
                 case 5 :
 15691  
                     // com\\googlecode\\sparkleg\\Sparql.g:471:7: blankNode
 15692  
                     {
 15693  192
                     root_0 = (Object)adaptor.nil();
 15694  
 
 15695  
 
 15696  192
                     pushFollow(FOLLOW_blankNode_in_graphTerm3856);
 15697  192
                     blankNode346=blankNode();
 15698  
 
 15699  192
                     state._fsp--;
 15700  
 
 15701  192
                     adaptor.addChild(root_0, blankNode346.getTree());
 15702  
 
 15703  
                     }
 15704  192
                     break;
 15705  
                 case 6 :
 15706  
                     // com\\googlecode\\sparkleg\\Sparql.g:472:7: nil
 15707  
                     {
 15708  10
                     root_0 = (Object)adaptor.nil();
 15709  
 
 15710  
 
 15711  10
                     pushFollow(FOLLOW_nil_in_graphTerm3864);
 15712  10
                     nil347=nil();
 15713  
 
 15714  10
                     state._fsp--;
 15715  
 
 15716  10
                     adaptor.addChild(root_0, nil347.getTree());
 15717  
 
 15718  
                     }
 15719  
                     break;
 15720  
 
 15721  
             }
 15722  1516
             retval.stop = input.LT(-1);
 15723  
 
 15724  
 
 15725  1516
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 15726  1516
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 15727  
 
 15728  
         }
 15729  0
         catch (RecognitionException re) {
 15730  0
             reportError(re);
 15731  0
             recover(input,re);
 15732  0
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 15733  
 
 15734  
         }
 15735  
 
 15736  0
         finally {
 15737  
                 // do for sure before leaving
 15738  1516
         }
 15739  1516
         return retval;
 15740  
     }
 15741  
     // $ANTLR end "graphTerm"
 15742  
 
 15743  
 
 15744  91
     public static class nil_return extends ParserRuleReturnScope {
 15745  
         Object tree;
 15746  91
         public Object getTree() { return tree; }
 15747  
     };
 15748  
 
 15749  
 
 15750  
     // $ANTLR start "nil"
 15751  
     // com\\googlecode\\sparkleg\\Sparql.g:475:1: nil : OPEN_BRACE CLOSE_BRACE ;
 15752  
     public final SparqlParser.nil_return nil() throws RecognitionException {
 15753  91
         SparqlParser.nil_return retval = new SparqlParser.nil_return();
 15754  91
         retval.start = input.LT(1);
 15755  
 
 15756  
 
 15757  91
         Object root_0 = null;
 15758  
 
 15759  91
         Token OPEN_BRACE348=null;
 15760  91
         Token CLOSE_BRACE349=null;
 15761  
 
 15762  91
         Object OPEN_BRACE348_tree=null;
 15763  91
         Object CLOSE_BRACE349_tree=null;
 15764  
 
 15765  
         try {
 15766  
             // com\\googlecode\\sparkleg\\Sparql.g:476:5: ( OPEN_BRACE CLOSE_BRACE )
 15767  
             // com\\googlecode\\sparkleg\\Sparql.g:476:7: OPEN_BRACE CLOSE_BRACE
 15768  
             {
 15769  91
             root_0 = (Object)adaptor.nil();
 15770  
 
 15771  
 
 15772  91
             OPEN_BRACE348=(Token)match(input,OPEN_BRACE,FOLLOW_OPEN_BRACE_in_nil3885); 
 15773  91
             OPEN_BRACE348_tree = 
 15774  
             (Object)adaptor.create(OPEN_BRACE348)
 15775  
             ;
 15776  91
             adaptor.addChild(root_0, OPEN_BRACE348_tree);
 15777  
 
 15778  
 
 15779  91
             CLOSE_BRACE349=(Token)match(input,CLOSE_BRACE,FOLLOW_CLOSE_BRACE_in_nil3887); 
 15780  91
             CLOSE_BRACE349_tree = 
 15781  
             (Object)adaptor.create(CLOSE_BRACE349)
 15782  
             ;
 15783  91
             adaptor.addChild(root_0, CLOSE_BRACE349_tree);
 15784  
 
 15785  
 
 15786  
             }
 15787  
 
 15788  91
             retval.stop = input.LT(-1);
 15789  
 
 15790  
 
 15791  91
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 15792  91
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 15793  
 
 15794  
         }
 15795  0
         catch (RecognitionException re) {
 15796  0
             reportError(re);
 15797  0
             recover(input,re);
 15798  0
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 15799  
 
 15800  
         }
 15801  
 
 15802  0
         finally {
 15803  
                 // do for sure before leaving
 15804  91
         }
 15805  91
         return retval;
 15806  
     }
 15807  
     // $ANTLR end "nil"
 15808  
 
 15809  
 
 15810  1640
     public static class expression_return extends ParserRuleReturnScope {
 15811  
         Object tree;
 15812  1640
         public Object getTree() { return tree; }
 15813  
     };
 15814  
 
 15815  
 
 15816  
     // $ANTLR start "expression"
 15817  
     // com\\googlecode\\sparkleg\\Sparql.g:479:1: expression : conditionalOrExpression ;
 15818  
     public final SparqlParser.expression_return expression() throws RecognitionException {
 15819  1640
         SparqlParser.expression_return retval = new SparqlParser.expression_return();
 15820  1640
         retval.start = input.LT(1);
 15821  
 
 15822  
 
 15823  1640
         Object root_0 = null;
 15824  
 
 15825  1640
         SparqlParser.conditionalOrExpression_return conditionalOrExpression350 =null;
 15826  
 
 15827  
 
 15828  
 
 15829  
         try {
 15830  
             // com\\googlecode\\sparkleg\\Sparql.g:480:5: ( conditionalOrExpression )
 15831  
             // com\\googlecode\\sparkleg\\Sparql.g:480:7: conditionalOrExpression
 15832  
             {
 15833  1640
             root_0 = (Object)adaptor.nil();
 15834  
 
 15835  
 
 15836  1640
             pushFollow(FOLLOW_conditionalOrExpression_in_expression3904);
 15837  1640
             conditionalOrExpression350=conditionalOrExpression();
 15838  
 
 15839  1640
             state._fsp--;
 15840  
 
 15841  1640
             adaptor.addChild(root_0, conditionalOrExpression350.getTree());
 15842  
 
 15843  
             }
 15844  
 
 15845  1640
             retval.stop = input.LT(-1);
 15846  
 
 15847  
 
 15848  1640
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 15849  1640
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 15850  
 
 15851  
         }
 15852  0
         catch (RecognitionException re) {
 15853  0
             reportError(re);
 15854  0
             recover(input,re);
 15855  0
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 15856  
 
 15857  
         }
 15858  
 
 15859  0
         finally {
 15860  
                 // do for sure before leaving
 15861  1640
         }
 15862  1640
         return retval;
 15863  
     }
 15864  
     // $ANTLR end "expression"
 15865  
 
 15866  
 
 15867  1640
     public static class conditionalOrExpression_return extends ParserRuleReturnScope {
 15868  
         Object tree;
 15869  1640
         public Object getTree() { return tree; }
 15870  
     };
 15871  
 
 15872  
 
 15873  
     // $ANTLR start "conditionalOrExpression"
 15874  
     // com\\googlecode\\sparkleg\\Sparql.g:483:1: conditionalOrExpression : (c1= conditionalAndExpression -> $c1) ( OR c2= conditionalAndExpression -> ^( OR $conditionalOrExpression $c2) )* ;
 15875  
     public final SparqlParser.conditionalOrExpression_return conditionalOrExpression() throws RecognitionException {
 15876  1640
         SparqlParser.conditionalOrExpression_return retval = new SparqlParser.conditionalOrExpression_return();
 15877  1640
         retval.start = input.LT(1);
 15878  
 
 15879  
 
 15880  1640
         Object root_0 = null;
 15881  
 
 15882  1640
         Token OR351=null;
 15883  1640
         SparqlParser.conditionalAndExpression_return c1 =null;
 15884  
 
 15885  1640
         SparqlParser.conditionalAndExpression_return c2 =null;
 15886  
 
 15887  
 
 15888  1640
         Object OR351_tree=null;
 15889  1640
         RewriteRuleTokenStream stream_OR=new RewriteRuleTokenStream(adaptor,"token OR");
 15890  1640
         RewriteRuleSubtreeStream stream_conditionalAndExpression=new RewriteRuleSubtreeStream(adaptor,"rule conditionalAndExpression");
 15891  
         try {
 15892  
             // com\\googlecode\\sparkleg\\Sparql.g:484:5: ( (c1= conditionalAndExpression -> $c1) ( OR c2= conditionalAndExpression -> ^( OR $conditionalOrExpression $c2) )* )
 15893  
             // com\\googlecode\\sparkleg\\Sparql.g:484:7: (c1= conditionalAndExpression -> $c1) ( OR c2= conditionalAndExpression -> ^( OR $conditionalOrExpression $c2) )*
 15894  
             {
 15895  
             // com\\googlecode\\sparkleg\\Sparql.g:484:7: (c1= conditionalAndExpression -> $c1)
 15896  
             // com\\googlecode\\sparkleg\\Sparql.g:484:8: c1= conditionalAndExpression
 15897  
             {
 15898  1640
             pushFollow(FOLLOW_conditionalAndExpression_in_conditionalOrExpression3924);
 15899  1640
             c1=conditionalAndExpression();
 15900  
 
 15901  1640
             state._fsp--;
 15902  
 
 15903  1640
             stream_conditionalAndExpression.add(c1.getTree());
 15904  
 
 15905  
             // AST REWRITE
 15906  
             // elements: c1
 15907  
             // token labels: 
 15908  
             // rule labels: retval, c1
 15909  
             // token list labels: 
 15910  
             // rule list labels: 
 15911  
             // wildcard labels: 
 15912  1640
             retval.tree = root_0;
 15913  1640
             RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 15914  1640
             RewriteRuleSubtreeStream stream_c1=new RewriteRuleSubtreeStream(adaptor,"rule c1",c1!=null?c1.tree:null);
 15915  
 
 15916  1640
             root_0 = (Object)adaptor.nil();
 15917  
             // 484:36: -> $c1
 15918  
             {
 15919  1640
                 adaptor.addChild(root_0, stream_c1.nextTree());
 15920  
 
 15921  
             }
 15922  
 
 15923  
 
 15924  1640
             retval.tree = root_0;
 15925  
 
 15926  
             }
 15927  
 
 15928  
 
 15929  
             // com\\googlecode\\sparkleg\\Sparql.g:484:44: ( OR c2= conditionalAndExpression -> ^( OR $conditionalOrExpression $c2) )*
 15930  
             loop117:
 15931  
             do {
 15932  1688
                 int alt117=2;
 15933  1688
                 switch ( input.LA(1) ) {
 15934  
                 case OR:
 15935  
                     {
 15936  48
                     alt117=1;
 15937  
                     }
 15938  
                     break;
 15939  
 
 15940  
                 }
 15941  
 
 15942  1688
                 switch (alt117) {
 15943  
                     case 1 :
 15944  
                         // com\\googlecode\\sparkleg\\Sparql.g:484:45: OR c2= conditionalAndExpression
 15945  
                         {
 15946  48
                         OR351=(Token)match(input,OR,FOLLOW_OR_in_conditionalOrExpression3933);  
 15947  48
                         stream_OR.add(OR351);
 15948  
 
 15949  
 
 15950  48
                         pushFollow(FOLLOW_conditionalAndExpression_in_conditionalOrExpression3937);
 15951  48
                         c2=conditionalAndExpression();
 15952  
 
 15953  48
                         state._fsp--;
 15954  
 
 15955  48
                         stream_conditionalAndExpression.add(c2.getTree());
 15956  
 
 15957  
                         // AST REWRITE
 15958  
                         // elements: conditionalOrExpression, OR, c2
 15959  
                         // token labels: 
 15960  
                         // rule labels: retval, c2
 15961  
                         // token list labels: 
 15962  
                         // rule list labels: 
 15963  
                         // wildcard labels: 
 15964  48
                         retval.tree = root_0;
 15965  48
                         RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 15966  48
                         RewriteRuleSubtreeStream stream_c2=new RewriteRuleSubtreeStream(adaptor,"rule c2",c2!=null?c2.tree:null);
 15967  
 
 15968  48
                         root_0 = (Object)adaptor.nil();
 15969  
                         // 484:76: -> ^( OR $conditionalOrExpression $c2)
 15970  
                         {
 15971  
                             // com\\googlecode\\sparkleg\\Sparql.g:484:79: ^( OR $conditionalOrExpression $c2)
 15972  
                             {
 15973  48
                             Object root_1 = (Object)adaptor.nil();
 15974  48
                             root_1 = (Object)adaptor.becomeRoot(
 15975  
                             stream_OR.nextNode()
 15976  
                             , root_1);
 15977  
 
 15978  48
                             adaptor.addChild(root_1, stream_retval.nextTree());
 15979  
 
 15980  48
                             adaptor.addChild(root_1, stream_c2.nextTree());
 15981  
 
 15982  48
                             adaptor.addChild(root_0, root_1);
 15983  
                             }
 15984  
 
 15985  
                         }
 15986  
 
 15987  
 
 15988  48
                         retval.tree = root_0;
 15989  
 
 15990  
                         }
 15991  48
                         break;
 15992  
 
 15993  
                     default :
 15994  1640
                         break loop117;
 15995  
                 }
 15996  48
             } while (true);
 15997  
 
 15998  
 
 15999  
             }
 16000  
 
 16001  1640
             retval.stop = input.LT(-1);
 16002  
 
 16003  
 
 16004  1640
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 16005  1640
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 16006  
 
 16007  
         }
 16008  0
         catch (RecognitionException re) {
 16009  0
             reportError(re);
 16010  0
             recover(input,re);
 16011  0
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 16012  
 
 16013  
         }
 16014  
 
 16015  0
         finally {
 16016  
                 // do for sure before leaving
 16017  1640
         }
 16018  1640
         return retval;
 16019  
     }
 16020  
     // $ANTLR end "conditionalOrExpression"
 16021  
 
 16022  
 
 16023  1688
     public static class conditionalAndExpression_return extends ParserRuleReturnScope {
 16024  
         Object tree;
 16025  1688
         public Object getTree() { return tree; }
 16026  
     };
 16027  
 
 16028  
 
 16029  
     // $ANTLR start "conditionalAndExpression"
 16030  
     // com\\googlecode\\sparkleg\\Sparql.g:487:1: conditionalAndExpression : (v1= valueLogical -> $v1) ( AND v2= valueLogical -> ^( AND $conditionalAndExpression $v2) )* ;
 16031  
     public final SparqlParser.conditionalAndExpression_return conditionalAndExpression() throws RecognitionException {
 16032  1688
         SparqlParser.conditionalAndExpression_return retval = new SparqlParser.conditionalAndExpression_return();
 16033  1688
         retval.start = input.LT(1);
 16034  
 
 16035  
 
 16036  1688
         Object root_0 = null;
 16037  
 
 16038  1688
         Token AND352=null;
 16039  1688
         SparqlParser.valueLogical_return v1 =null;
 16040  
 
 16041  1688
         SparqlParser.valueLogical_return v2 =null;
 16042  
 
 16043  
 
 16044  1688
         Object AND352_tree=null;
 16045  1688
         RewriteRuleTokenStream stream_AND=new RewriteRuleTokenStream(adaptor,"token AND");
 16046  1688
         RewriteRuleSubtreeStream stream_valueLogical=new RewriteRuleSubtreeStream(adaptor,"rule valueLogical");
 16047  
         try {
 16048  
             // com\\googlecode\\sparkleg\\Sparql.g:488:5: ( (v1= valueLogical -> $v1) ( AND v2= valueLogical -> ^( AND $conditionalAndExpression $v2) )* )
 16049  
             // com\\googlecode\\sparkleg\\Sparql.g:488:7: (v1= valueLogical -> $v1) ( AND v2= valueLogical -> ^( AND $conditionalAndExpression $v2) )*
 16050  
             {
 16051  
             // com\\googlecode\\sparkleg\\Sparql.g:488:7: (v1= valueLogical -> $v1)
 16052  
             // com\\googlecode\\sparkleg\\Sparql.g:488:8: v1= valueLogical
 16053  
             {
 16054  1688
             pushFollow(FOLLOW_valueLogical_in_conditionalAndExpression3971);
 16055  1688
             v1=valueLogical();
 16056  
 
 16057  1688
             state._fsp--;
 16058  
 
 16059  1688
             stream_valueLogical.add(v1.getTree());
 16060  
 
 16061  
             // AST REWRITE
 16062  
             // elements: v1
 16063  
             // token labels: 
 16064  
             // rule labels: v1, retval
 16065  
             // token list labels: 
 16066  
             // rule list labels: 
 16067  
             // wildcard labels: 
 16068  1688
             retval.tree = root_0;
 16069  1688
             RewriteRuleSubtreeStream stream_v1=new RewriteRuleSubtreeStream(adaptor,"rule v1",v1!=null?v1.tree:null);
 16070  1688
             RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 16071  
 
 16072  1688
             root_0 = (Object)adaptor.nil();
 16073  
             // 488:24: -> $v1
 16074  
             {
 16075  1688
                 adaptor.addChild(root_0, stream_v1.nextTree());
 16076  
 
 16077  
             }
 16078  
 
 16079  
 
 16080  1688
             retval.tree = root_0;
 16081  
 
 16082  
             }
 16083  
 
 16084  
 
 16085  
             // com\\googlecode\\sparkleg\\Sparql.g:488:32: ( AND v2= valueLogical -> ^( AND $conditionalAndExpression $v2) )*
 16086  
             loop118:
 16087  
             do {
 16088  1736
                 int alt118=2;
 16089  1736
                 switch ( input.LA(1) ) {
 16090  
                 case AND:
 16091  
                     {
 16092  48
                     alt118=1;
 16093  
                     }
 16094  
                     break;
 16095  
 
 16096  
                 }
 16097  
 
 16098  1736
                 switch (alt118) {
 16099  
                     case 1 :
 16100  
                         // com\\googlecode\\sparkleg\\Sparql.g:488:33: AND v2= valueLogical
 16101  
                         {
 16102  48
                         AND352=(Token)match(input,AND,FOLLOW_AND_in_conditionalAndExpression3980);  
 16103  48
                         stream_AND.add(AND352);
 16104  
 
 16105  
 
 16106  48
                         pushFollow(FOLLOW_valueLogical_in_conditionalAndExpression3984);
 16107  48
                         v2=valueLogical();
 16108  
 
 16109  48
                         state._fsp--;
 16110  
 
 16111  48
                         stream_valueLogical.add(v2.getTree());
 16112  
 
 16113  
                         // AST REWRITE
 16114  
                         // elements: AND, v2, conditionalAndExpression
 16115  
                         // token labels: 
 16116  
                         // rule labels: retval, v2
 16117  
                         // token list labels: 
 16118  
                         // rule list labels: 
 16119  
                         // wildcard labels: 
 16120  48
                         retval.tree = root_0;
 16121  48
                         RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 16122  48
                         RewriteRuleSubtreeStream stream_v2=new RewriteRuleSubtreeStream(adaptor,"rule v2",v2!=null?v2.tree:null);
 16123  
 
 16124  48
                         root_0 = (Object)adaptor.nil();
 16125  
                         // 488:53: -> ^( AND $conditionalAndExpression $v2)
 16126  
                         {
 16127  
                             // com\\googlecode\\sparkleg\\Sparql.g:488:56: ^( AND $conditionalAndExpression $v2)
 16128  
                             {
 16129  48
                             Object root_1 = (Object)adaptor.nil();
 16130  48
                             root_1 = (Object)adaptor.becomeRoot(
 16131  
                             stream_AND.nextNode()
 16132  
                             , root_1);
 16133  
 
 16134  48
                             adaptor.addChild(root_1, stream_retval.nextTree());
 16135  
 
 16136  48
                             adaptor.addChild(root_1, stream_v2.nextTree());
 16137  
 
 16138  48
                             adaptor.addChild(root_0, root_1);
 16139  
                             }
 16140  
 
 16141  
                         }
 16142  
 
 16143  
 
 16144  48
                         retval.tree = root_0;
 16145  
 
 16146  
                         }
 16147  48
                         break;
 16148  
 
 16149  
                     default :
 16150  1688
                         break loop118;
 16151  
                 }
 16152  48
             } while (true);
 16153  
 
 16154  
 
 16155  
             }
 16156  
 
 16157  1688
             retval.stop = input.LT(-1);
 16158  
 
 16159  
 
 16160  1688
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 16161  1688
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 16162  
 
 16163  
         }
 16164  0
         catch (RecognitionException re) {
 16165  0
             reportError(re);
 16166  0
             recover(input,re);
 16167  0
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 16168  
 
 16169  
         }
 16170  
 
 16171  0
         finally {
 16172  
                 // do for sure before leaving
 16173  1688
         }
 16174  1688
         return retval;
 16175  
     }
 16176  
     // $ANTLR end "conditionalAndExpression"
 16177  
 
 16178  
 
 16179  1736
     public static class valueLogical_return extends ParserRuleReturnScope {
 16180  
         Object tree;
 16181  1736
         public Object getTree() { return tree; }
 16182  
     };
 16183  
 
 16184  
 
 16185  
     // $ANTLR start "valueLogical"
 16186  
     // com\\googlecode\\sparkleg\\Sparql.g:491:1: valueLogical : relationalExpression ;
 16187  
     public final SparqlParser.valueLogical_return valueLogical() throws RecognitionException {
 16188  1736
         SparqlParser.valueLogical_return retval = new SparqlParser.valueLogical_return();
 16189  1736
         retval.start = input.LT(1);
 16190  
 
 16191  
 
 16192  1736
         Object root_0 = null;
 16193  
 
 16194  1736
         SparqlParser.relationalExpression_return relationalExpression353 =null;
 16195  
 
 16196  
 
 16197  
 
 16198  
         try {
 16199  
             // com\\googlecode\\sparkleg\\Sparql.g:492:5: ( relationalExpression )
 16200  
             // com\\googlecode\\sparkleg\\Sparql.g:492:7: relationalExpression
 16201  
             {
 16202  1736
             root_0 = (Object)adaptor.nil();
 16203  
 
 16204  
 
 16205  1736
             pushFollow(FOLLOW_relationalExpression_in_valueLogical4015);
 16206  1736
             relationalExpression353=relationalExpression();
 16207  
 
 16208  1736
             state._fsp--;
 16209  
 
 16210  1736
             adaptor.addChild(root_0, relationalExpression353.getTree());
 16211  
 
 16212  
             }
 16213  
 
 16214  1736
             retval.stop = input.LT(-1);
 16215  
 
 16216  
 
 16217  1736
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 16218  1736
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 16219  
 
 16220  
         }
 16221  0
         catch (RecognitionException re) {
 16222  0
             reportError(re);
 16223  0
             recover(input,re);
 16224  0
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 16225  
 
 16226  
         }
 16227  
 
 16228  0
         finally {
 16229  
                 // do for sure before leaving
 16230  1736
         }
 16231  1736
         return retval;
 16232  
     }
 16233  
     // $ANTLR end "valueLogical"
 16234  
 
 16235  
 
 16236  1736
     public static class relationalExpression_return extends ParserRuleReturnScope {
 16237  
         Object tree;
 16238  1736
         public Object getTree() { return tree; }
 16239  
     };
 16240  
 
 16241  
 
 16242  
     // $ANTLR start "relationalExpression"
 16243  
     // com\\googlecode\\sparkleg\\Sparql.g:495:1: relationalExpression : (n1= numericExpression -> $n1) ( ( EQUAL n2= numericExpression -> ^( EQUAL $relationalExpression $n2) ) | ( NOT_EQUAL n3= numericExpression -> ^( NOT_EQUAL $relationalExpression $n3) ) | ( LESS n4= numericExpression -> ^( LESS $relationalExpression $n4) ) | ( GREATER n5= numericExpression -> ^( GREATER $relationalExpression $n5) ) | ( LESS_EQUAL n6= numericExpression -> ^( LESS_EQUAL $relationalExpression $n6) ) | ( GREATER_EQUAL n7= numericExpression -> ^( GREATER_EQUAL $relationalExpression $n7) ) | ( IN l2= expressionList -> ^( IN $relationalExpression $l2) ) | ( NOT IN l3= expressionList -> ^( NOT IN $relationalExpression $l3) ) )? ;
 16244  
     public final SparqlParser.relationalExpression_return relationalExpression() throws RecognitionException {
 16245  1736
         SparqlParser.relationalExpression_return retval = new SparqlParser.relationalExpression_return();
 16246  1736
         retval.start = input.LT(1);
 16247  
 
 16248  
 
 16249  1736
         Object root_0 = null;
 16250  
 
 16251  1736
         Token EQUAL354=null;
 16252  1736
         Token NOT_EQUAL355=null;
 16253  1736
         Token LESS356=null;
 16254  1736
         Token GREATER357=null;
 16255  1736
         Token LESS_EQUAL358=null;
 16256  1736
         Token GREATER_EQUAL359=null;
 16257  1736
         Token IN360=null;
 16258  1736
         Token NOT361=null;
 16259  1736
         Token IN362=null;
 16260  1736
         SparqlParser.numericExpression_return n1 =null;
 16261  
 
 16262  1736
         SparqlParser.numericExpression_return n2 =null;
 16263  
 
 16264  1736
         SparqlParser.numericExpression_return n3 =null;
 16265  
 
 16266  1736
         SparqlParser.numericExpression_return n4 =null;
 16267  
 
 16268  1736
         SparqlParser.numericExpression_return n5 =null;
 16269  
 
 16270  1736
         SparqlParser.numericExpression_return n6 =null;
 16271  
 
 16272  1736
         SparqlParser.numericExpression_return n7 =null;
 16273  
 
 16274  1736
         SparqlParser.expressionList_return l2 =null;
 16275  
 
 16276  1736
         SparqlParser.expressionList_return l3 =null;
 16277  
 
 16278  
 
 16279  1736
         Object EQUAL354_tree=null;
 16280  1736
         Object NOT_EQUAL355_tree=null;
 16281  1736
         Object LESS356_tree=null;
 16282  1736
         Object GREATER357_tree=null;
 16283  1736
         Object LESS_EQUAL358_tree=null;
 16284  1736
         Object GREATER_EQUAL359_tree=null;
 16285  1736
         Object IN360_tree=null;
 16286  1736
         Object NOT361_tree=null;
 16287  1736
         Object IN362_tree=null;
 16288  1736
         RewriteRuleTokenStream stream_GREATER=new RewriteRuleTokenStream(adaptor,"token GREATER");
 16289  1736
         RewriteRuleTokenStream stream_LESS_EQUAL=new RewriteRuleTokenStream(adaptor,"token LESS_EQUAL");
 16290  1736
         RewriteRuleTokenStream stream_IN=new RewriteRuleTokenStream(adaptor,"token IN");
 16291  1736
         RewriteRuleTokenStream stream_NOT=new RewriteRuleTokenStream(adaptor,"token NOT");
 16292  1736
         RewriteRuleTokenStream stream_NOT_EQUAL=new RewriteRuleTokenStream(adaptor,"token NOT_EQUAL");
 16293  1736
         RewriteRuleTokenStream stream_GREATER_EQUAL=new RewriteRuleTokenStream(adaptor,"token GREATER_EQUAL");
 16294  1736
         RewriteRuleTokenStream stream_EQUAL=new RewriteRuleTokenStream(adaptor,"token EQUAL");
 16295  1736
         RewriteRuleTokenStream stream_LESS=new RewriteRuleTokenStream(adaptor,"token LESS");
 16296  1736
         RewriteRuleSubtreeStream stream_expressionList=new RewriteRuleSubtreeStream(adaptor,"rule expressionList");
 16297  1736
         RewriteRuleSubtreeStream stream_numericExpression=new RewriteRuleSubtreeStream(adaptor,"rule numericExpression");
 16298  
         try {
 16299  
             // com\\googlecode\\sparkleg\\Sparql.g:496:5: ( (n1= numericExpression -> $n1) ( ( EQUAL n2= numericExpression -> ^( EQUAL $relationalExpression $n2) ) | ( NOT_EQUAL n3= numericExpression -> ^( NOT_EQUAL $relationalExpression $n3) ) | ( LESS n4= numericExpression -> ^( LESS $relationalExpression $n4) ) | ( GREATER n5= numericExpression -> ^( GREATER $relationalExpression $n5) ) | ( LESS_EQUAL n6= numericExpression -> ^( LESS_EQUAL $relationalExpression $n6) ) | ( GREATER_EQUAL n7= numericExpression -> ^( GREATER_EQUAL $relationalExpression $n7) ) | ( IN l2= expressionList -> ^( IN $relationalExpression $l2) ) | ( NOT IN l3= expressionList -> ^( NOT IN $relationalExpression $l3) ) )? )
 16300  
             // com\\googlecode\\sparkleg\\Sparql.g:496:7: (n1= numericExpression -> $n1) ( ( EQUAL n2= numericExpression -> ^( EQUAL $relationalExpression $n2) ) | ( NOT_EQUAL n3= numericExpression -> ^( NOT_EQUAL $relationalExpression $n3) ) | ( LESS n4= numericExpression -> ^( LESS $relationalExpression $n4) ) | ( GREATER n5= numericExpression -> ^( GREATER $relationalExpression $n5) ) | ( LESS_EQUAL n6= numericExpression -> ^( LESS_EQUAL $relationalExpression $n6) ) | ( GREATER_EQUAL n7= numericExpression -> ^( GREATER_EQUAL $relationalExpression $n7) ) | ( IN l2= expressionList -> ^( IN $relationalExpression $l2) ) | ( NOT IN l3= expressionList -> ^( NOT IN $relationalExpression $l3) ) )?
 16301  
             {
 16302  
             // com\\googlecode\\sparkleg\\Sparql.g:496:7: (n1= numericExpression -> $n1)
 16303  
             // com\\googlecode\\sparkleg\\Sparql.g:496:8: n1= numericExpression
 16304  
             {
 16305  1736
             pushFollow(FOLLOW_numericExpression_in_relationalExpression4035);
 16306  1736
             n1=numericExpression();
 16307  
 
 16308  1736
             state._fsp--;
 16309  
 
 16310  1736
             stream_numericExpression.add(n1.getTree());
 16311  
 
 16312  
             // AST REWRITE
 16313  
             // elements: n1
 16314  
             // token labels: 
 16315  
             // rule labels: n1, retval
 16316  
             // token list labels: 
 16317  
             // rule list labels: 
 16318  
             // wildcard labels: 
 16319  1736
             retval.tree = root_0;
 16320  1736
             RewriteRuleSubtreeStream stream_n1=new RewriteRuleSubtreeStream(adaptor,"rule n1",n1!=null?n1.tree:null);
 16321  1736
             RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 16322  
 
 16323  1736
             root_0 = (Object)adaptor.nil();
 16324  
             // 496:29: -> $n1
 16325  
             {
 16326  1736
                 adaptor.addChild(root_0, stream_n1.nextTree());
 16327  
 
 16328  
             }
 16329  
 
 16330  
 
 16331  1736
             retval.tree = root_0;
 16332  
 
 16333  
             }
 16334  
 
 16335  
 
 16336  
             // com\\googlecode\\sparkleg\\Sparql.g:496:37: ( ( EQUAL n2= numericExpression -> ^( EQUAL $relationalExpression $n2) ) | ( NOT_EQUAL n3= numericExpression -> ^( NOT_EQUAL $relationalExpression $n3) ) | ( LESS n4= numericExpression -> ^( LESS $relationalExpression $n4) ) | ( GREATER n5= numericExpression -> ^( GREATER $relationalExpression $n5) ) | ( LESS_EQUAL n6= numericExpression -> ^( LESS_EQUAL $relationalExpression $n6) ) | ( GREATER_EQUAL n7= numericExpression -> ^( GREATER_EQUAL $relationalExpression $n7) ) | ( IN l2= expressionList -> ^( IN $relationalExpression $l2) ) | ( NOT IN l3= expressionList -> ^( NOT IN $relationalExpression $l3) ) )?
 16337  1736
             int alt119=9;
 16338  1736
             switch ( input.LA(1) ) {
 16339  
                 case EQUAL:
 16340  
                     {
 16341  276
                     alt119=1;
 16342  
                     }
 16343  276
                     break;
 16344  
                 case NOT_EQUAL:
 16345  
                     {
 16346  56
                     alt119=2;
 16347  
                     }
 16348  56
                     break;
 16349  
                 case LESS:
 16350  
                     {
 16351  36
                     alt119=3;
 16352  
                     }
 16353  36
                     break;
 16354  
                 case GREATER:
 16355  
                     {
 16356  36
                     alt119=4;
 16357  
                     }
 16358  36
                     break;
 16359  
                 case LESS_EQUAL:
 16360  
                     {
 16361  4
                     alt119=5;
 16362  
                     }
 16363  4
                     break;
 16364  
                 case GREATER_EQUAL:
 16365  
                     {
 16366  6
                     alt119=6;
 16367  
                     }
 16368  6
                     break;
 16369  
                 case IN:
 16370  
                     {
 16371  4
                     alt119=7;
 16372  
                     }
 16373  4
                     break;
 16374  
                 case NOT:
 16375  
                     {
 16376  4
                     alt119=8;
 16377  
                     }
 16378  
                     break;
 16379  
             }
 16380  
 
 16381  1736
             switch (alt119) {
 16382  
                 case 1 :
 16383  
                     // com\\googlecode\\sparkleg\\Sparql.g:496:38: ( EQUAL n2= numericExpression -> ^( EQUAL $relationalExpression $n2) )
 16384  
                     {
 16385  
                     // com\\googlecode\\sparkleg\\Sparql.g:496:38: ( EQUAL n2= numericExpression -> ^( EQUAL $relationalExpression $n2) )
 16386  
                     // com\\googlecode\\sparkleg\\Sparql.g:496:39: EQUAL n2= numericExpression
 16387  
                     {
 16388  276
                     EQUAL354=(Token)match(input,EQUAL,FOLLOW_EQUAL_in_relationalExpression4045);  
 16389  276
                     stream_EQUAL.add(EQUAL354);
 16390  
 
 16391  
 
 16392  276
                     pushFollow(FOLLOW_numericExpression_in_relationalExpression4049);
 16393  276
                     n2=numericExpression();
 16394  
 
 16395  276
                     state._fsp--;
 16396  
 
 16397  276
                     stream_numericExpression.add(n2.getTree());
 16398  
 
 16399  
                     // AST REWRITE
 16400  
                     // elements: EQUAL, relationalExpression, n2
 16401  
                     // token labels: 
 16402  
                     // rule labels: retval, n2
 16403  
                     // token list labels: 
 16404  
                     // rule list labels: 
 16405  
                     // wildcard labels: 
 16406  276
                     retval.tree = root_0;
 16407  276
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 16408  276
                     RewriteRuleSubtreeStream stream_n2=new RewriteRuleSubtreeStream(adaptor,"rule n2",n2!=null?n2.tree:null);
 16409  
 
 16410  276
                     root_0 = (Object)adaptor.nil();
 16411  
                     // 496:66: -> ^( EQUAL $relationalExpression $n2)
 16412  
                     {
 16413  
                         // com\\googlecode\\sparkleg\\Sparql.g:496:69: ^( EQUAL $relationalExpression $n2)
 16414  
                         {
 16415  276
                         Object root_1 = (Object)adaptor.nil();
 16416  276
                         root_1 = (Object)adaptor.becomeRoot(
 16417  
                         stream_EQUAL.nextNode()
 16418  
                         , root_1);
 16419  
 
 16420  276
                         adaptor.addChild(root_1, stream_retval.nextTree());
 16421  
 
 16422  276
                         adaptor.addChild(root_1, stream_n2.nextTree());
 16423  
 
 16424  276
                         adaptor.addChild(root_0, root_1);
 16425  
                         }
 16426  
 
 16427  
                     }
 16428  
 
 16429  
 
 16430  276
                     retval.tree = root_0;
 16431  
 
 16432  
                     }
 16433  
 
 16434  
 
 16435  
                     }
 16436  276
                     break;
 16437  
                 case 2 :
 16438  
                     // com\\googlecode\\sparkleg\\Sparql.g:497:39: ( NOT_EQUAL n3= numericExpression -> ^( NOT_EQUAL $relationalExpression $n3) )
 16439  
                     {
 16440  
                     // com\\googlecode\\sparkleg\\Sparql.g:497:39: ( NOT_EQUAL n3= numericExpression -> ^( NOT_EQUAL $relationalExpression $n3) )
 16441  
                     // com\\googlecode\\sparkleg\\Sparql.g:497:40: NOT_EQUAL n3= numericExpression
 16442  
                     {
 16443  56
                     NOT_EQUAL355=(Token)match(input,NOT_EQUAL,FOLLOW_NOT_EQUAL_in_relationalExpression4106);  
 16444  56
                     stream_NOT_EQUAL.add(NOT_EQUAL355);
 16445  
 
 16446  
 
 16447  56
                     pushFollow(FOLLOW_numericExpression_in_relationalExpression4110);
 16448  56
                     n3=numericExpression();
 16449  
 
 16450  56
                     state._fsp--;
 16451  
 
 16452  56
                     stream_numericExpression.add(n3.getTree());
 16453  
 
 16454  
                     // AST REWRITE
 16455  
                     // elements: n3, relationalExpression, NOT_EQUAL
 16456  
                     // token labels: 
 16457  
                     // rule labels: retval, n3
 16458  
                     // token list labels: 
 16459  
                     // rule list labels: 
 16460  
                     // wildcard labels: 
 16461  56
                     retval.tree = root_0;
 16462  56
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 16463  56
                     RewriteRuleSubtreeStream stream_n3=new RewriteRuleSubtreeStream(adaptor,"rule n3",n3!=null?n3.tree:null);
 16464  
 
 16465  56
                     root_0 = (Object)adaptor.nil();
 16466  
                     // 497:71: -> ^( NOT_EQUAL $relationalExpression $n3)
 16467  
                     {
 16468  
                         // com\\googlecode\\sparkleg\\Sparql.g:497:74: ^( NOT_EQUAL $relationalExpression $n3)
 16469  
                         {
 16470  56
                         Object root_1 = (Object)adaptor.nil();
 16471  56
                         root_1 = (Object)adaptor.becomeRoot(
 16472  
                         stream_NOT_EQUAL.nextNode()
 16473  
                         , root_1);
 16474  
 
 16475  56
                         adaptor.addChild(root_1, stream_retval.nextTree());
 16476  
 
 16477  56
                         adaptor.addChild(root_1, stream_n3.nextTree());
 16478  
 
 16479  56
                         adaptor.addChild(root_0, root_1);
 16480  
                         }
 16481  
 
 16482  
                     }
 16483  
 
 16484  
 
 16485  56
                     retval.tree = root_0;
 16486  
 
 16487  
                     }
 16488  
 
 16489  
 
 16490  
                     }
 16491  56
                     break;
 16492  
                 case 3 :
 16493  
                     // com\\googlecode\\sparkleg\\Sparql.g:498:39: ( LESS n4= numericExpression -> ^( LESS $relationalExpression $n4) )
 16494  
                     {
 16495  
                     // com\\googlecode\\sparkleg\\Sparql.g:498:39: ( LESS n4= numericExpression -> ^( LESS $relationalExpression $n4) )
 16496  
                     // com\\googlecode\\sparkleg\\Sparql.g:498:40: LESS n4= numericExpression
 16497  
                     {
 16498  36
                     LESS356=(Token)match(input,LESS,FOLLOW_LESS_in_relationalExpression4165);  
 16499  36
                     stream_LESS.add(LESS356);
 16500  
 
 16501  
 
 16502  36
                     pushFollow(FOLLOW_numericExpression_in_relationalExpression4169);
 16503  36
                     n4=numericExpression();
 16504  
 
 16505  36
                     state._fsp--;
 16506  
 
 16507  36
                     stream_numericExpression.add(n4.getTree());
 16508  
 
 16509  
                     // AST REWRITE
 16510  
                     // elements: n4, LESS, relationalExpression
 16511  
                     // token labels: 
 16512  
                     // rule labels: retval, n4
 16513  
                     // token list labels: 
 16514  
                     // rule list labels: 
 16515  
                     // wildcard labels: 
 16516  36
                     retval.tree = root_0;
 16517  36
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 16518  36
                     RewriteRuleSubtreeStream stream_n4=new RewriteRuleSubtreeStream(adaptor,"rule n4",n4!=null?n4.tree:null);
 16519  
 
 16520  36
                     root_0 = (Object)adaptor.nil();
 16521  
                     // 498:66: -> ^( LESS $relationalExpression $n4)
 16522  
                     {
 16523  
                         // com\\googlecode\\sparkleg\\Sparql.g:498:69: ^( LESS $relationalExpression $n4)
 16524  
                         {
 16525  36
                         Object root_1 = (Object)adaptor.nil();
 16526  36
                         root_1 = (Object)adaptor.becomeRoot(
 16527  
                         stream_LESS.nextNode()
 16528  
                         , root_1);
 16529  
 
 16530  36
                         adaptor.addChild(root_1, stream_retval.nextTree());
 16531  
 
 16532  36
                         adaptor.addChild(root_1, stream_n4.nextTree());
 16533  
 
 16534  36
                         adaptor.addChild(root_0, root_1);
 16535  
                         }
 16536  
 
 16537  
                     }
 16538  
 
 16539  
 
 16540  36
                     retval.tree = root_0;
 16541  
 
 16542  
                     }
 16543  
 
 16544  
 
 16545  
                     }
 16546  36
                     break;
 16547  
                 case 4 :
 16548  
                     // com\\googlecode\\sparkleg\\Sparql.g:499:39: ( GREATER n5= numericExpression -> ^( GREATER $relationalExpression $n5) )
 16549  
                     {
 16550  
                     // com\\googlecode\\sparkleg\\Sparql.g:499:39: ( GREATER n5= numericExpression -> ^( GREATER $relationalExpression $n5) )
 16551  
                     // com\\googlecode\\sparkleg\\Sparql.g:499:40: GREATER n5= numericExpression
 16552  
                     {
 16553  36
                     GREATER357=(Token)match(input,GREATER,FOLLOW_GREATER_in_relationalExpression4224);  
 16554  36
                     stream_GREATER.add(GREATER357);
 16555  
 
 16556  
 
 16557  36
                     pushFollow(FOLLOW_numericExpression_in_relationalExpression4228);
 16558  36
                     n5=numericExpression();
 16559  
 
 16560  36
                     state._fsp--;
 16561  
 
 16562  36
                     stream_numericExpression.add(n5.getTree());
 16563  
 
 16564  
                     // AST REWRITE
 16565  
                     // elements: n5, relationalExpression, GREATER
 16566  
                     // token labels: 
 16567  
                     // rule labels: retval, n5
 16568  
                     // token list labels: 
 16569  
                     // rule list labels: 
 16570  
                     // wildcard labels: 
 16571  36
                     retval.tree = root_0;
 16572  36
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 16573  36
                     RewriteRuleSubtreeStream stream_n5=new RewriteRuleSubtreeStream(adaptor,"rule n5",n5!=null?n5.tree:null);
 16574  
 
 16575  36
                     root_0 = (Object)adaptor.nil();
 16576  
                     // 499:69: -> ^( GREATER $relationalExpression $n5)
 16577  
                     {
 16578  
                         // com\\googlecode\\sparkleg\\Sparql.g:499:72: ^( GREATER $relationalExpression $n5)
 16579  
                         {
 16580  36
                         Object root_1 = (Object)adaptor.nil();
 16581  36
                         root_1 = (Object)adaptor.becomeRoot(
 16582  
                         stream_GREATER.nextNode()
 16583  
                         , root_1);
 16584  
 
 16585  36
                         adaptor.addChild(root_1, stream_retval.nextTree());
 16586  
 
 16587  36
                         adaptor.addChild(root_1, stream_n5.nextTree());
 16588  
 
 16589  36
                         adaptor.addChild(root_0, root_1);
 16590  
                         }
 16591  
 
 16592  
                     }
 16593  
 
 16594  
 
 16595  36
                     retval.tree = root_0;
 16596  
 
 16597  
                     }
 16598  
 
 16599  
 
 16600  
                     }
 16601  36
                     break;
 16602  
                 case 5 :
 16603  
                     // com\\googlecode\\sparkleg\\Sparql.g:500:39: ( LESS_EQUAL n6= numericExpression -> ^( LESS_EQUAL $relationalExpression $n6) )
 16604  
                     {
 16605  
                     // com\\googlecode\\sparkleg\\Sparql.g:500:39: ( LESS_EQUAL n6= numericExpression -> ^( LESS_EQUAL $relationalExpression $n6) )
 16606  
                     // com\\googlecode\\sparkleg\\Sparql.g:500:40: LESS_EQUAL n6= numericExpression
 16607  
                     {
 16608  4
                     LESS_EQUAL358=(Token)match(input,LESS_EQUAL,FOLLOW_LESS_EQUAL_in_relationalExpression4282);  
 16609  4
                     stream_LESS_EQUAL.add(LESS_EQUAL358);
 16610  
 
 16611  
 
 16612  4
                     pushFollow(FOLLOW_numericExpression_in_relationalExpression4286);
 16613  4
                     n6=numericExpression();
 16614  
 
 16615  4
                     state._fsp--;
 16616  
 
 16617  4
                     stream_numericExpression.add(n6.getTree());
 16618  
 
 16619  
                     // AST REWRITE
 16620  
                     // elements: n6, relationalExpression, LESS_EQUAL
 16621  
                     // token labels: 
 16622  
                     // rule labels: retval, n6
 16623  
                     // token list labels: 
 16624  
                     // rule list labels: 
 16625  
                     // wildcard labels: 
 16626  4
                     retval.tree = root_0;
 16627  4
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 16628  4
                     RewriteRuleSubtreeStream stream_n6=new RewriteRuleSubtreeStream(adaptor,"rule n6",n6!=null?n6.tree:null);
 16629  
 
 16630  4
                     root_0 = (Object)adaptor.nil();
 16631  
                     // 500:72: -> ^( LESS_EQUAL $relationalExpression $n6)
 16632  
                     {
 16633  
                         // com\\googlecode\\sparkleg\\Sparql.g:500:75: ^( LESS_EQUAL $relationalExpression $n6)
 16634  
                         {
 16635  4
                         Object root_1 = (Object)adaptor.nil();
 16636  4
                         root_1 = (Object)adaptor.becomeRoot(
 16637  
                         stream_LESS_EQUAL.nextNode()
 16638  
                         , root_1);
 16639  
 
 16640  4
                         adaptor.addChild(root_1, stream_retval.nextTree());
 16641  
 
 16642  4
                         adaptor.addChild(root_1, stream_n6.nextTree());
 16643  
 
 16644  4
                         adaptor.addChild(root_0, root_1);
 16645  
                         }
 16646  
 
 16647  
                     }
 16648  
 
 16649  
 
 16650  4
                     retval.tree = root_0;
 16651  
 
 16652  
                     }
 16653  
 
 16654  
 
 16655  
                     }
 16656  4
                     break;
 16657  
                 case 6 :
 16658  
                     // com\\googlecode\\sparkleg\\Sparql.g:501:39: ( GREATER_EQUAL n7= numericExpression -> ^( GREATER_EQUAL $relationalExpression $n7) )
 16659  
                     {
 16660  
                     // com\\googlecode\\sparkleg\\Sparql.g:501:39: ( GREATER_EQUAL n7= numericExpression -> ^( GREATER_EQUAL $relationalExpression $n7) )
 16661  
                     // com\\googlecode\\sparkleg\\Sparql.g:501:40: GREATER_EQUAL n7= numericExpression
 16662  
                     {
 16663  6
                     GREATER_EQUAL359=(Token)match(input,GREATER_EQUAL,FOLLOW_GREATER_EQUAL_in_relationalExpression4340);  
 16664  6
                     stream_GREATER_EQUAL.add(GREATER_EQUAL359);
 16665  
 
 16666  
 
 16667  6
                     pushFollow(FOLLOW_numericExpression_in_relationalExpression4344);
 16668  6
                     n7=numericExpression();
 16669  
 
 16670  6
                     state._fsp--;
 16671  
 
 16672  6
                     stream_numericExpression.add(n7.getTree());
 16673  
 
 16674  
                     // AST REWRITE
 16675  
                     // elements: n7, relationalExpression, GREATER_EQUAL
 16676  
                     // token labels: 
 16677  
                     // rule labels: retval, n7
 16678  
                     // token list labels: 
 16679  
                     // rule list labels: 
 16680  
                     // wildcard labels: 
 16681  6
                     retval.tree = root_0;
 16682  6
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 16683  6
                     RewriteRuleSubtreeStream stream_n7=new RewriteRuleSubtreeStream(adaptor,"rule n7",n7!=null?n7.tree:null);
 16684  
 
 16685  6
                     root_0 = (Object)adaptor.nil();
 16686  
                     // 501:75: -> ^( GREATER_EQUAL $relationalExpression $n7)
 16687  
                     {
 16688  
                         // com\\googlecode\\sparkleg\\Sparql.g:501:78: ^( GREATER_EQUAL $relationalExpression $n7)
 16689  
                         {
 16690  6
                         Object root_1 = (Object)adaptor.nil();
 16691  6
                         root_1 = (Object)adaptor.becomeRoot(
 16692  
                         stream_GREATER_EQUAL.nextNode()
 16693  
                         , root_1);
 16694  
 
 16695  6
                         adaptor.addChild(root_1, stream_retval.nextTree());
 16696  
 
 16697  6
                         adaptor.addChild(root_1, stream_n7.nextTree());
 16698  
 
 16699  6
                         adaptor.addChild(root_0, root_1);
 16700  
                         }
 16701  
 
 16702  
                     }
 16703  
 
 16704  
 
 16705  6
                     retval.tree = root_0;
 16706  
 
 16707  
                     }
 16708  
 
 16709  
 
 16710  
                     }
 16711  6
                     break;
 16712  
                 case 7 :
 16713  
                     // com\\googlecode\\sparkleg\\Sparql.g:502:39: ( IN l2= expressionList -> ^( IN $relationalExpression $l2) )
 16714  
                     {
 16715  
                     // com\\googlecode\\sparkleg\\Sparql.g:502:39: ( IN l2= expressionList -> ^( IN $relationalExpression $l2) )
 16716  
                     // com\\googlecode\\sparkleg\\Sparql.g:502:40: IN l2= expressionList
 16717  
                     {
 16718  4
                     IN360=(Token)match(input,IN,FOLLOW_IN_in_relationalExpression4400);  
 16719  4
                     stream_IN.add(IN360);
 16720  
 
 16721  
 
 16722  4
                     pushFollow(FOLLOW_expressionList_in_relationalExpression4404);
 16723  4
                     l2=expressionList();
 16724  
 
 16725  4
                     state._fsp--;
 16726  
 
 16727  4
                     stream_expressionList.add(l2.getTree());
 16728  
 
 16729  
                     // AST REWRITE
 16730  
                     // elements: IN, relationalExpression, l2
 16731  
                     // token labels: 
 16732  
                     // rule labels: retval, l2
 16733  
                     // token list labels: 
 16734  
                     // rule list labels: 
 16735  
                     // wildcard labels: 
 16736  4
                     retval.tree = root_0;
 16737  4
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 16738  4
                     RewriteRuleSubtreeStream stream_l2=new RewriteRuleSubtreeStream(adaptor,"rule l2",l2!=null?l2.tree:null);
 16739  
 
 16740  4
                     root_0 = (Object)adaptor.nil();
 16741  
                     // 502:61: -> ^( IN $relationalExpression $l2)
 16742  
                     {
 16743  
                         // com\\googlecode\\sparkleg\\Sparql.g:502:64: ^( IN $relationalExpression $l2)
 16744  
                         {
 16745  4
                         Object root_1 = (Object)adaptor.nil();
 16746  4
                         root_1 = (Object)adaptor.becomeRoot(
 16747  
                         stream_IN.nextNode()
 16748  
                         , root_1);
 16749  
 
 16750  4
                         adaptor.addChild(root_1, stream_retval.nextTree());
 16751  
 
 16752  4
                         adaptor.addChild(root_1, stream_l2.nextTree());
 16753  
 
 16754  4
                         adaptor.addChild(root_0, root_1);
 16755  
                         }
 16756  
 
 16757  
                     }
 16758  
 
 16759  
 
 16760  4
                     retval.tree = root_0;
 16761  
 
 16762  
                     }
 16763  
 
 16764  
 
 16765  
                     }
 16766  4
                     break;
 16767  
                 case 8 :
 16768  
                     // com\\googlecode\\sparkleg\\Sparql.g:503:39: ( NOT IN l3= expressionList -> ^( NOT IN $relationalExpression $l3) )
 16769  
                     {
 16770  
                     // com\\googlecode\\sparkleg\\Sparql.g:503:39: ( NOT IN l3= expressionList -> ^( NOT IN $relationalExpression $l3) )
 16771  
                     // com\\googlecode\\sparkleg\\Sparql.g:503:40: NOT IN l3= expressionList
 16772  
                     {
 16773  4
                     NOT361=(Token)match(input,NOT,FOLLOW_NOT_in_relationalExpression4458);  
 16774  4
                     stream_NOT.add(NOT361);
 16775  
 
 16776  
 
 16777  4
                     IN362=(Token)match(input,IN,FOLLOW_IN_in_relationalExpression4460);  
 16778  4
                     stream_IN.add(IN362);
 16779  
 
 16780  
 
 16781  4
                     pushFollow(FOLLOW_expressionList_in_relationalExpression4464);
 16782  4
                     l3=expressionList();
 16783  
 
 16784  4
                     state._fsp--;
 16785  
 
 16786  4
                     stream_expressionList.add(l3.getTree());
 16787  
 
 16788  
                     // AST REWRITE
 16789  
                     // elements: IN, NOT, l3, relationalExpression
 16790  
                     // token labels: 
 16791  
                     // rule labels: retval, l3
 16792  
                     // token list labels: 
 16793  
                     // rule list labels: 
 16794  
                     // wildcard labels: 
 16795  4
                     retval.tree = root_0;
 16796  4
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 16797  4
                     RewriteRuleSubtreeStream stream_l3=new RewriteRuleSubtreeStream(adaptor,"rule l3",l3!=null?l3.tree:null);
 16798  
 
 16799  4
                     root_0 = (Object)adaptor.nil();
 16800  
                     // 503:65: -> ^( NOT IN $relationalExpression $l3)
 16801  
                     {
 16802  
                         // com\\googlecode\\sparkleg\\Sparql.g:503:68: ^( NOT IN $relationalExpression $l3)
 16803  
                         {
 16804  4
                         Object root_1 = (Object)adaptor.nil();
 16805  4
                         root_1 = (Object)adaptor.becomeRoot(
 16806  
                         stream_NOT.nextNode()
 16807  
                         , root_1);
 16808  
 
 16809  4
                         adaptor.addChild(root_1, 
 16810  
                         stream_IN.nextNode()
 16811  
                         );
 16812  
 
 16813  4
                         adaptor.addChild(root_1, stream_retval.nextTree());
 16814  
 
 16815  4
                         adaptor.addChild(root_1, stream_l3.nextTree());
 16816  
 
 16817  4
                         adaptor.addChild(root_0, root_1);
 16818  
                         }
 16819  
 
 16820  
                     }
 16821  
 
 16822  
 
 16823  4
                     retval.tree = root_0;
 16824  
 
 16825  
                     }
 16826  
 
 16827  
 
 16828  
                     }
 16829  
                     break;
 16830  
 
 16831  
             }
 16832  
 
 16833  
 
 16834  
             }
 16835  
 
 16836  1736
             retval.stop = input.LT(-1);
 16837  
 
 16838  
 
 16839  1736
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 16840  1736
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 16841  
 
 16842  
         }
 16843  0
         catch (RecognitionException re) {
 16844  0
             reportError(re);
 16845  0
             recover(input,re);
 16846  0
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 16847  
 
 16848  
         }
 16849  
 
 16850  0
         finally {
 16851  
                 // do for sure before leaving
 16852  1736
         }
 16853  1736
         return retval;
 16854  
     }
 16855  
     // $ANTLR end "relationalExpression"
 16856  
 
 16857  
 
 16858  2150
     public static class numericExpression_return extends ParserRuleReturnScope {
 16859  
         Object tree;
 16860  2150
         public Object getTree() { return tree; }
 16861  
     };
 16862  
 
 16863  
 
 16864  
     // $ANTLR start "numericExpression"
 16865  
     // com\\googlecode\\sparkleg\\Sparql.g:506:1: numericExpression : additiveExpression ;
 16866  
     public final SparqlParser.numericExpression_return numericExpression() throws RecognitionException {
 16867  2150
         SparqlParser.numericExpression_return retval = new SparqlParser.numericExpression_return();
 16868  2150
         retval.start = input.LT(1);
 16869  
 
 16870  
 
 16871  2150
         Object root_0 = null;
 16872  
 
 16873  2150
         SparqlParser.additiveExpression_return additiveExpression363 =null;
 16874  
 
 16875  
 
 16876  
 
 16877  
         try {
 16878  
             // com\\googlecode\\sparkleg\\Sparql.g:507:5: ( additiveExpression )
 16879  
             // com\\googlecode\\sparkleg\\Sparql.g:507:7: additiveExpression
 16880  
             {
 16881  2150
             root_0 = (Object)adaptor.nil();
 16882  
 
 16883  
 
 16884  2150
             pushFollow(FOLLOW_additiveExpression_in_numericExpression4498);
 16885  2150
             additiveExpression363=additiveExpression();
 16886  
 
 16887  2150
             state._fsp--;
 16888  
 
 16889  2150
             adaptor.addChild(root_0, additiveExpression363.getTree());
 16890  
 
 16891  
             }
 16892  
 
 16893  2150
             retval.stop = input.LT(-1);
 16894  
 
 16895  
 
 16896  2150
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 16897  2150
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 16898  
 
 16899  
         }
 16900  0
         catch (RecognitionException re) {
 16901  0
             reportError(re);
 16902  0
             recover(input,re);
 16903  0
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 16904  
 
 16905  
         }
 16906  
 
 16907  0
         finally {
 16908  
                 // do for sure before leaving
 16909  2150
         }
 16910  2150
         return retval;
 16911  
     }
 16912  
     // $ANTLR end "numericExpression"
 16913  
 
 16914  
 
 16915  2150
     public static class additiveExpression_return extends ParserRuleReturnScope {
 16916  
         Object tree;
 16917  2150
         public Object getTree() { return tree; }
 16918  
     };
 16919  
 
 16920  
 
 16921  
     // $ANTLR start "additiveExpression"
 16922  
     // com\\googlecode\\sparkleg\\Sparql.g:510:1: additiveExpression : (m1= multiplicativeExpression -> $m1) ( ( additiveOperator m2= multiplicativeExpression -> ^( additiveOperator $additiveExpression $m2) ) | (n1= numericLiteralPositive -> ^( PLUS $additiveExpression $n1) |n2= numericLiteralNegative -> ^( PLUS $additiveExpression $n2) ) ( ( ( ASTERISK u2= unaryExpression -> ^( ASTERISK $additiveExpression $u2) ) ) | ( ( DIVIDE u2= unaryExpression -> ^( DIVIDE $additiveExpression $u2) ) ) )? )* ;
 16923  
     public final SparqlParser.additiveExpression_return additiveExpression() throws RecognitionException {
 16924  2150
         SparqlParser.additiveExpression_return retval = new SparqlParser.additiveExpression_return();
 16925  2150
         retval.start = input.LT(1);
 16926  
 
 16927  
 
 16928  2150
         Object root_0 = null;
 16929  
 
 16930  2150
         Token ASTERISK365=null;
 16931  2150
         Token DIVIDE366=null;
 16932  2150
         SparqlParser.multiplicativeExpression_return m1 =null;
 16933  
 
 16934  2150
         SparqlParser.multiplicativeExpression_return m2 =null;
 16935  
 
 16936  2150
         SparqlParser.numericLiteralPositive_return n1 =null;
 16937  
 
 16938  2150
         SparqlParser.numericLiteralNegative_return n2 =null;
 16939  
 
 16940  2150
         SparqlParser.unaryExpression_return u2 =null;
 16941  
 
 16942  2150
         SparqlParser.additiveOperator_return additiveOperator364 =null;
 16943  
 
 16944  
 
 16945  2150
         Object ASTERISK365_tree=null;
 16946  2150
         Object DIVIDE366_tree=null;
 16947  2150
         RewriteRuleTokenStream stream_ASTERISK=new RewriteRuleTokenStream(adaptor,"token ASTERISK");
 16948  2150
         RewriteRuleTokenStream stream_DIVIDE=new RewriteRuleTokenStream(adaptor,"token DIVIDE");
 16949  2150
         RewriteRuleSubtreeStream stream_unaryExpression=new RewriteRuleSubtreeStream(adaptor,"rule unaryExpression");
 16950  2150
         RewriteRuleSubtreeStream stream_numericLiteralNegative=new RewriteRuleSubtreeStream(adaptor,"rule numericLiteralNegative");
 16951  2150
         RewriteRuleSubtreeStream stream_numericLiteralPositive=new RewriteRuleSubtreeStream(adaptor,"rule numericLiteralPositive");
 16952  2150
         RewriteRuleSubtreeStream stream_additiveOperator=new RewriteRuleSubtreeStream(adaptor,"rule additiveOperator");
 16953  2150
         RewriteRuleSubtreeStream stream_multiplicativeExpression=new RewriteRuleSubtreeStream(adaptor,"rule multiplicativeExpression");
 16954  
         try {
 16955  
             // com\\googlecode\\sparkleg\\Sparql.g:511:5: ( (m1= multiplicativeExpression -> $m1) ( ( additiveOperator m2= multiplicativeExpression -> ^( additiveOperator $additiveExpression $m2) ) | (n1= numericLiteralPositive -> ^( PLUS $additiveExpression $n1) |n2= numericLiteralNegative -> ^( PLUS $additiveExpression $n2) ) ( ( ( ASTERISK u2= unaryExpression -> ^( ASTERISK $additiveExpression $u2) ) ) | ( ( DIVIDE u2= unaryExpression -> ^( DIVIDE $additiveExpression $u2) ) ) )? )* )
 16956  
             // com\\googlecode\\sparkleg\\Sparql.g:511:7: (m1= multiplicativeExpression -> $m1) ( ( additiveOperator m2= multiplicativeExpression -> ^( additiveOperator $additiveExpression $m2) ) | (n1= numericLiteralPositive -> ^( PLUS $additiveExpression $n1) |n2= numericLiteralNegative -> ^( PLUS $additiveExpression $n2) ) ( ( ( ASTERISK u2= unaryExpression -> ^( ASTERISK $additiveExpression $u2) ) ) | ( ( DIVIDE u2= unaryExpression -> ^( DIVIDE $additiveExpression $u2) ) ) )? )*
 16957  
             {
 16958  
             // com\\googlecode\\sparkleg\\Sparql.g:511:7: (m1= multiplicativeExpression -> $m1)
 16959  
             // com\\googlecode\\sparkleg\\Sparql.g:511:8: m1= multiplicativeExpression
 16960  
             {
 16961  2150
             pushFollow(FOLLOW_multiplicativeExpression_in_additiveExpression4518);
 16962  2150
             m1=multiplicativeExpression();
 16963  
 
 16964  2150
             state._fsp--;
 16965  
 
 16966  2150
             stream_multiplicativeExpression.add(m1.getTree());
 16967  
 
 16968  
             // AST REWRITE
 16969  
             // elements: m1
 16970  
             // token labels: 
 16971  
             // rule labels: retval, m1
 16972  
             // token list labels: 
 16973  
             // rule list labels: 
 16974  
             // wildcard labels: 
 16975  2150
             retval.tree = root_0;
 16976  2150
             RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 16977  2150
             RewriteRuleSubtreeStream stream_m1=new RewriteRuleSubtreeStream(adaptor,"rule m1",m1!=null?m1.tree:null);
 16978  
 
 16979  2150
             root_0 = (Object)adaptor.nil();
 16980  
             // 511:36: -> $m1
 16981  
             {
 16982  2150
                 adaptor.addChild(root_0, stream_m1.nextTree());
 16983  
 
 16984  
             }
 16985  
 
 16986  
 
 16987  2150
             retval.tree = root_0;
 16988  
 
 16989  
             }
 16990  
 
 16991  
 
 16992  
             // com\\googlecode\\sparkleg\\Sparql.g:511:44: ( ( additiveOperator m2= multiplicativeExpression -> ^( additiveOperator $additiveExpression $m2) ) | (n1= numericLiteralPositive -> ^( PLUS $additiveExpression $n1) |n2= numericLiteralNegative -> ^( PLUS $additiveExpression $n2) ) ( ( ( ASTERISK u2= unaryExpression -> ^( ASTERISK $additiveExpression $u2) ) ) | ( ( DIVIDE u2= unaryExpression -> ^( DIVIDE $additiveExpression $u2) ) ) )? )*
 16993  
             loop122:
 16994  
             do {
 16995  2296
                 int alt122=3;
 16996  2296
                 switch ( input.LA(1) ) {
 16997  
                 case MINUS:
 16998  
                 case PLUS:
 16999  
                     {
 17000  126
                     alt122=1;
 17001  
                     }
 17002  126
                     break;
 17003  
                 case DECIMAL_NEGATIVE:
 17004  
                 case DECIMAL_POSITIVE:
 17005  
                 case DOUBLE_NEGATIVE:
 17006  
                 case DOUBLE_POSITIVE:
 17007  
                 case INTEGER_NEGATIVE:
 17008  
                 case INTEGER_POSITIVE:
 17009  
                     {
 17010  20
                     alt122=2;
 17011  
                     }
 17012  
                     break;
 17013  
 
 17014  
                 }
 17015  
 
 17016  2296
                 switch (alt122) {
 17017  
                     case 1 :
 17018  
                         // com\\googlecode\\sparkleg\\Sparql.g:511:45: ( additiveOperator m2= multiplicativeExpression -> ^( additiveOperator $additiveExpression $m2) )
 17019  
                         {
 17020  
                         // com\\googlecode\\sparkleg\\Sparql.g:511:45: ( additiveOperator m2= multiplicativeExpression -> ^( additiveOperator $additiveExpression $m2) )
 17021  
                         // com\\googlecode\\sparkleg\\Sparql.g:511:46: additiveOperator m2= multiplicativeExpression
 17022  
                         {
 17023  126
                         pushFollow(FOLLOW_additiveOperator_in_additiveExpression4528);
 17024  126
                         additiveOperator364=additiveOperator();
 17025  
 
 17026  126
                         state._fsp--;
 17027  
 
 17028  126
                         stream_additiveOperator.add(additiveOperator364.getTree());
 17029  
 
 17030  126
                         pushFollow(FOLLOW_multiplicativeExpression_in_additiveExpression4532);
 17031  126
                         m2=multiplicativeExpression();
 17032  
 
 17033  126
                         state._fsp--;
 17034  
 
 17035  126
                         stream_multiplicativeExpression.add(m2.getTree());
 17036  
 
 17037  
                         // AST REWRITE
 17038  
                         // elements: m2, additiveOperator, additiveExpression
 17039  
                         // token labels: 
 17040  
                         // rule labels: retval, m2
 17041  
                         // token list labels: 
 17042  
                         // rule list labels: 
 17043  
                         // wildcard labels: 
 17044  126
                         retval.tree = root_0;
 17045  126
                         RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 17046  126
                         RewriteRuleSubtreeStream stream_m2=new RewriteRuleSubtreeStream(adaptor,"rule m2",m2!=null?m2.tree:null);
 17047  
 
 17048  126
                         root_0 = (Object)adaptor.nil();
 17049  
                         // 511:91: -> ^( additiveOperator $additiveExpression $m2)
 17050  
                         {
 17051  
                             // com\\googlecode\\sparkleg\\Sparql.g:511:94: ^( additiveOperator $additiveExpression $m2)
 17052  
                             {
 17053  126
                             Object root_1 = (Object)adaptor.nil();
 17054  126
                             root_1 = (Object)adaptor.becomeRoot(stream_additiveOperator.nextNode(), root_1);
 17055  
 
 17056  126
                             adaptor.addChild(root_1, stream_retval.nextTree());
 17057  
 
 17058  126
                             adaptor.addChild(root_1, stream_m2.nextTree());
 17059  
 
 17060  126
                             adaptor.addChild(root_0, root_1);
 17061  
                             }
 17062  
 
 17063  
                         }
 17064  
 
 17065  
 
 17066  126
                         retval.tree = root_0;
 17067  
 
 17068  
                         }
 17069  
 
 17070  
 
 17071  
                         }
 17072  126
                         break;
 17073  
                     case 2 :
 17074  
                         // com\\googlecode\\sparkleg\\Sparql.g:512:48: (n1= numericLiteralPositive -> ^( PLUS $additiveExpression $n1) |n2= numericLiteralNegative -> ^( PLUS $additiveExpression $n2) ) ( ( ( ASTERISK u2= unaryExpression -> ^( ASTERISK $additiveExpression $u2) ) ) | ( ( DIVIDE u2= unaryExpression -> ^( DIVIDE $additiveExpression $u2) ) ) )?
 17075  
                         {
 17076  
                         // com\\googlecode\\sparkleg\\Sparql.g:512:48: (n1= numericLiteralPositive -> ^( PLUS $additiveExpression $n1) |n2= numericLiteralNegative -> ^( PLUS $additiveExpression $n2) )
 17077  20
                         int alt120=2;
 17078  20
                         switch ( input.LA(1) ) {
 17079  
                         case DECIMAL_POSITIVE:
 17080  
                         case DOUBLE_POSITIVE:
 17081  
                         case INTEGER_POSITIVE:
 17082  
                             {
 17083  20
                             alt120=1;
 17084  
                             }
 17085  20
                             break;
 17086  
                         case DECIMAL_NEGATIVE:
 17087  
                         case DOUBLE_NEGATIVE:
 17088  
                         case INTEGER_NEGATIVE:
 17089  
                             {
 17090  0
                             alt120=2;
 17091  
                             }
 17092  0
                             break;
 17093  
                         default:
 17094  0
                             NoViableAltException nvae =
 17095  
                                 new NoViableAltException("", 120, 0, input);
 17096  
 
 17097  0
                             throw nvae;
 17098  
 
 17099  
                         }
 17100  
 
 17101  20
                         switch (alt120) {
 17102  
                             case 1 :
 17103  
                                 // com\\googlecode\\sparkleg\\Sparql.g:512:49: n1= numericLiteralPositive
 17104  
                                 {
 17105  20
                                 pushFollow(FOLLOW_numericLiteralPositive_in_additiveExpression4599);
 17106  20
                                 n1=numericLiteralPositive();
 17107  
 
 17108  20
                                 state._fsp--;
 17109  
 
 17110  20
                                 stream_numericLiteralPositive.add(n1.getTree());
 17111  
 
 17112  
                                 // AST REWRITE
 17113  
                                 // elements: n1, additiveExpression
 17114  
                                 // token labels: 
 17115  
                                 // rule labels: n1, retval
 17116  
                                 // token list labels: 
 17117  
                                 // rule list labels: 
 17118  
                                 // wildcard labels: 
 17119  20
                                 retval.tree = root_0;
 17120  20
                                 RewriteRuleSubtreeStream stream_n1=new RewriteRuleSubtreeStream(adaptor,"rule n1",n1!=null?n1.tree:null);
 17121  20
                                 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 17122  
 
 17123  20
                                 root_0 = (Object)adaptor.nil();
 17124  
                                 // 512:75: -> ^( PLUS $additiveExpression $n1)
 17125  
                                 {
 17126  
                                     // com\\googlecode\\sparkleg\\Sparql.g:512:78: ^( PLUS $additiveExpression $n1)
 17127  
                                     {
 17128  20
                                     Object root_1 = (Object)adaptor.nil();
 17129  20
                                     root_1 = (Object)adaptor.becomeRoot(
 17130  
                                     (Object)adaptor.create(PLUS, "PLUS")
 17131  
                                     , root_1);
 17132  
 
 17133  20
                                     adaptor.addChild(root_1, stream_retval.nextTree());
 17134  
 
 17135  20
                                     adaptor.addChild(root_1, stream_n1.nextTree());
 17136  
 
 17137  20
                                     adaptor.addChild(root_0, root_1);
 17138  
                                     }
 17139  
 
 17140  
                                 }
 17141  
 
 17142  
 
 17143  20
                                 retval.tree = root_0;
 17144  
 
 17145  
                                 }
 17146  20
                                 break;
 17147  
                             case 2 :
 17148  
                                 // com\\googlecode\\sparkleg\\Sparql.g:512:112: n2= numericLiteralNegative
 17149  
                                 {
 17150  0
                                 pushFollow(FOLLOW_numericLiteralNegative_in_additiveExpression4617);
 17151  0
                                 n2=numericLiteralNegative();
 17152  
 
 17153  0
                                 state._fsp--;
 17154  
 
 17155  0
                                 stream_numericLiteralNegative.add(n2.getTree());
 17156  
 
 17157  
                                 // AST REWRITE
 17158  
                                 // elements: n2, additiveExpression
 17159  
                                 // token labels: 
 17160  
                                 // rule labels: retval, n2
 17161  
                                 // token list labels: 
 17162  
                                 // rule list labels: 
 17163  
                                 // wildcard labels: 
 17164  0
                                 retval.tree = root_0;
 17165  0
                                 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 17166  0
                                 RewriteRuleSubtreeStream stream_n2=new RewriteRuleSubtreeStream(adaptor,"rule n2",n2!=null?n2.tree:null);
 17167  
 
 17168  0
                                 root_0 = (Object)adaptor.nil();
 17169  
                                 // 512:138: -> ^( PLUS $additiveExpression $n2)
 17170  
                                 {
 17171  
                                     // com\\googlecode\\sparkleg\\Sparql.g:512:141: ^( PLUS $additiveExpression $n2)
 17172  
                                     {
 17173  0
                                     Object root_1 = (Object)adaptor.nil();
 17174  0
                                     root_1 = (Object)adaptor.becomeRoot(
 17175  
                                     (Object)adaptor.create(PLUS, "PLUS")
 17176  
                                     , root_1);
 17177  
 
 17178  0
                                     adaptor.addChild(root_1, stream_retval.nextTree());
 17179  
 
 17180  0
                                     adaptor.addChild(root_1, stream_n2.nextTree());
 17181  
 
 17182  0
                                     adaptor.addChild(root_0, root_1);
 17183  
                                     }
 17184  
 
 17185  
                                 }
 17186  
 
 17187  
 
 17188  0
                                 retval.tree = root_0;
 17189  
 
 17190  
                                 }
 17191  
                                 break;
 17192  
 
 17193  
                         }
 17194  
 
 17195  
 
 17196  
                         // com\\googlecode\\sparkleg\\Sparql.g:513:46: ( ( ( ASTERISK u2= unaryExpression -> ^( ASTERISK $additiveExpression $u2) ) ) | ( ( DIVIDE u2= unaryExpression -> ^( DIVIDE $additiveExpression $u2) ) ) )?
 17197  20
                         int alt121=3;
 17198  20
                         switch ( input.LA(1) ) {
 17199  
                             case ASTERISK:
 17200  
                                 {
 17201  0
                                 alt121=1;
 17202  
                                 }
 17203  0
                                 break;
 17204  
                             case DIVIDE:
 17205  
                                 {
 17206  0
                                 alt121=2;
 17207  
                                 }
 17208  
                                 break;
 17209  
                         }
 17210  
 
 17211  20
                         switch (alt121) {
 17212  
                             case 1 :
 17213  
                                 // com\\googlecode\\sparkleg\\Sparql.g:513:47: ( ( ASTERISK u2= unaryExpression -> ^( ASTERISK $additiveExpression $u2) ) )
 17214  
                                 {
 17215  
                                 // com\\googlecode\\sparkleg\\Sparql.g:513:47: ( ( ASTERISK u2= unaryExpression -> ^( ASTERISK $additiveExpression $u2) ) )
 17216  
                                 // com\\googlecode\\sparkleg\\Sparql.g:513:48: ( ASTERISK u2= unaryExpression -> ^( ASTERISK $additiveExpression $u2) )
 17217  
                                 {
 17218  
                                 // com\\googlecode\\sparkleg\\Sparql.g:513:48: ( ASTERISK u2= unaryExpression -> ^( ASTERISK $additiveExpression $u2) )
 17219  
                                 // com\\googlecode\\sparkleg\\Sparql.g:513:49: ASTERISK u2= unaryExpression
 17220  
                                 {
 17221  0
                                 ASTERISK365=(Token)match(input,ASTERISK,FOLLOW_ASTERISK_in_additiveExpression4681);  
 17222  0
                                 stream_ASTERISK.add(ASTERISK365);
 17223  
 
 17224  
 
 17225  0
                                 pushFollow(FOLLOW_unaryExpression_in_additiveExpression4685);
 17226  0
                                 u2=unaryExpression();
 17227  
 
 17228  0
                                 state._fsp--;
 17229  
 
 17230  0
                                 stream_unaryExpression.add(u2.getTree());
 17231  
 
 17232  
                                 // AST REWRITE
 17233  
                                 // elements: u2, additiveExpression, ASTERISK
 17234  
                                 // token labels: 
 17235  
                                 // rule labels: retval, u2
 17236  
                                 // token list labels: 
 17237  
                                 // rule list labels: 
 17238  
                                 // wildcard labels: 
 17239  0
                                 retval.tree = root_0;
 17240  0
                                 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 17241  0
                                 RewriteRuleSubtreeStream stream_u2=new RewriteRuleSubtreeStream(adaptor,"rule u2",u2!=null?u2.tree:null);
 17242  
 
 17243  0
                                 root_0 = (Object)adaptor.nil();
 17244  
                                 // 513:77: -> ^( ASTERISK $additiveExpression $u2)
 17245  
                                 {
 17246  
                                     // com\\googlecode\\sparkleg\\Sparql.g:513:80: ^( ASTERISK $additiveExpression $u2)
 17247  
                                     {
 17248  0
                                     Object root_1 = (Object)adaptor.nil();
 17249  0
                                     root_1 = (Object)adaptor.becomeRoot(
 17250  
                                     stream_ASTERISK.nextNode()
 17251  
                                     , root_1);
 17252  
 
 17253  0
                                     adaptor.addChild(root_1, stream_retval.nextTree());
 17254  
 
 17255  0
                                     adaptor.addChild(root_1, stream_u2.nextTree());
 17256  
 
 17257  0
                                     adaptor.addChild(root_0, root_1);
 17258  
                                     }
 17259  
 
 17260  
                                 }
 17261  
 
 17262  
 
 17263  0
                                 retval.tree = root_0;
 17264  
 
 17265  
                                 }
 17266  
 
 17267  
 
 17268  
                                 }
 17269  
 
 17270  
 
 17271  
                                 }
 17272  0
                                 break;
 17273  
                             case 2 :
 17274  
                                 // com\\googlecode\\sparkleg\\Sparql.g:514:48: ( ( DIVIDE u2= unaryExpression -> ^( DIVIDE $additiveExpression $u2) ) )
 17275  
                                 {
 17276  
                                 // com\\googlecode\\sparkleg\\Sparql.g:514:48: ( ( DIVIDE u2= unaryExpression -> ^( DIVIDE $additiveExpression $u2) ) )
 17277  
                                 // com\\googlecode\\sparkleg\\Sparql.g:514:49: ( DIVIDE u2= unaryExpression -> ^( DIVIDE $additiveExpression $u2) )
 17278  
                                 {
 17279  
                                 // com\\googlecode\\sparkleg\\Sparql.g:514:49: ( DIVIDE u2= unaryExpression -> ^( DIVIDE $additiveExpression $u2) )
 17280  
                                 // com\\googlecode\\sparkleg\\Sparql.g:514:50: DIVIDE u2= unaryExpression
 17281  
                                 {
 17282  0
                                 DIVIDE366=(Token)match(input,DIVIDE,FOLLOW_DIVIDE_in_additiveExpression4751);  
 17283  0
                                 stream_DIVIDE.add(DIVIDE366);
 17284  
 
 17285  
 
 17286  0
                                 pushFollow(FOLLOW_unaryExpression_in_additiveExpression4755);
 17287  0
                                 u2=unaryExpression();
 17288  
 
 17289  0
                                 state._fsp--;
 17290  
 
 17291  0
                                 stream_unaryExpression.add(u2.getTree());
 17292  
 
 17293  
                                 // AST REWRITE
 17294  
                                 // elements: u2, additiveExpression, DIVIDE
 17295  
                                 // token labels: 
 17296  
                                 // rule labels: retval, u2
 17297  
                                 // token list labels: 
 17298  
                                 // rule list labels: 
 17299  
                                 // wildcard labels: 
 17300  0
                                 retval.tree = root_0;
 17301  0
                                 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 17302  0
                                 RewriteRuleSubtreeStream stream_u2=new RewriteRuleSubtreeStream(adaptor,"rule u2",u2!=null?u2.tree:null);
 17303  
 
 17304  0
                                 root_0 = (Object)adaptor.nil();
 17305  
                                 // 514:76: -> ^( DIVIDE $additiveExpression $u2)
 17306  
                                 {
 17307  
                                     // com\\googlecode\\sparkleg\\Sparql.g:514:79: ^( DIVIDE $additiveExpression $u2)
 17308  
                                     {
 17309  0
                                     Object root_1 = (Object)adaptor.nil();
 17310  0
                                     root_1 = (Object)adaptor.becomeRoot(
 17311  
                                     stream_DIVIDE.nextNode()
 17312  
                                     , root_1);
 17313  
 
 17314  0
                                     adaptor.addChild(root_1, stream_retval.nextTree());
 17315  
 
 17316  0
                                     adaptor.addChild(root_1, stream_u2.nextTree());
 17317  
 
 17318  0
                                     adaptor.addChild(root_0, root_1);
 17319  
                                     }
 17320  
 
 17321  
                                 }
 17322  
 
 17323  
 
 17324  0
                                 retval.tree = root_0;
 17325  
 
 17326  
                                 }
 17327  
 
 17328  
 
 17329  
                                 }
 17330  
 
 17331  
 
 17332  
                                 }
 17333  
                                 break;
 17334  
 
 17335  
                         }
 17336  
 
 17337  
 
 17338  
                         }
 17339  20
                         break;
 17340  
 
 17341  
                     default :
 17342  2150
                         break loop122;
 17343  
                 }
 17344  146
             } while (true);
 17345  
 
 17346  
 
 17347  
             }
 17348  
 
 17349  2150
             retval.stop = input.LT(-1);
 17350  
 
 17351  
 
 17352  2150
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 17353  2150
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 17354  
 
 17355  
         }
 17356  0
         catch (RecognitionException re) {
 17357  0
             reportError(re);
 17358  0
             recover(input,re);
 17359  0
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 17360  
 
 17361  
         }
 17362  
 
 17363  0
         finally {
 17364  
                 // do for sure before leaving
 17365  2150
         }
 17366  2150
         return retval;
 17367  
     }
 17368  
     // $ANTLR end "additiveExpression"
 17369  
 
 17370  
 
 17371  126
     public static class additiveOperator_return extends ParserRuleReturnScope {
 17372  
         Object tree;
 17373  126
         public Object getTree() { return tree; }
 17374  
     };
 17375  
 
 17376  
 
 17377  
     // $ANTLR start "additiveOperator"
 17378  
     // com\\googlecode\\sparkleg\\Sparql.g:517:1: additiveOperator : ( PLUS | MINUS );
 17379  
     public final SparqlParser.additiveOperator_return additiveOperator() throws RecognitionException {
 17380  126
         SparqlParser.additiveOperator_return retval = new SparqlParser.additiveOperator_return();
 17381  126
         retval.start = input.LT(1);
 17382  
 
 17383  
 
 17384  126
         Object root_0 = null;
 17385  
 
 17386  126
         Token set367=null;
 17387  
 
 17388  126
         Object set367_tree=null;
 17389  
 
 17390  
         try {
 17391  
             // com\\googlecode\\sparkleg\\Sparql.g:518:5: ( PLUS | MINUS )
 17392  
             // com\\googlecode\\sparkleg\\Sparql.g:
 17393  
             {
 17394  126
             root_0 = (Object)adaptor.nil();
 17395  
 
 17396  
 
 17397  126
             set367=(Token)input.LT(1);
 17398  
 
 17399  126
             if ( input.LA(1)==MINUS||input.LA(1)==PLUS ) {
 17400  126
                 input.consume();
 17401  126
                 adaptor.addChild(root_0, 
 17402  
                 (Object)adaptor.create(set367)
 17403  
                 );
 17404  126
                 state.errorRecovery=false;
 17405  
             }
 17406  
             else {
 17407  0
                 MismatchedSetException mse = new MismatchedSetException(null,input);
 17408  0
                 throw mse;
 17409  
             }
 17410  
 
 17411  
 
 17412  
             }
 17413  
 
 17414  126
             retval.stop = input.LT(-1);
 17415  
 
 17416  
 
 17417  126
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 17418  126
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 17419  
 
 17420  
         }
 17421  0
         catch (RecognitionException re) {
 17422  0
             reportError(re);
 17423  0
             recover(input,re);
 17424  0
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 17425  
 
 17426  
         }
 17427  
 
 17428  0
         finally {
 17429  
                 // do for sure before leaving
 17430  126
         }
 17431  126
         return retval;
 17432  
     }
 17433  
     // $ANTLR end "additiveOperator"
 17434  
 
 17435  
 
 17436  2276
     public static class multiplicativeExpression_return extends ParserRuleReturnScope {
 17437  
         Object tree;
 17438  2276
         public Object getTree() { return tree; }
 17439  
     };
 17440  
 
 17441  
 
 17442  
     // $ANTLR start "multiplicativeExpression"
 17443  
     // com\\googlecode\\sparkleg\\Sparql.g:521:1: multiplicativeExpression : (u1= unaryExpression -> $u1) ( multiplicativeOperator u2= unaryExpression -> ^( multiplicativeOperator $multiplicativeExpression $u2) )* ;
 17444  
     public final SparqlParser.multiplicativeExpression_return multiplicativeExpression() throws RecognitionException {
 17445  2276
         SparqlParser.multiplicativeExpression_return retval = new SparqlParser.multiplicativeExpression_return();
 17446  2276
         retval.start = input.LT(1);
 17447  
 
 17448  
 
 17449  2276
         Object root_0 = null;
 17450  
 
 17451  2276
         SparqlParser.unaryExpression_return u1 =null;
 17452  
 
 17453  2276
         SparqlParser.unaryExpression_return u2 =null;
 17454  
 
 17455  2276
         SparqlParser.multiplicativeOperator_return multiplicativeOperator368 =null;
 17456  
 
 17457  
 
 17458  2276
         RewriteRuleSubtreeStream stream_multiplicativeOperator=new RewriteRuleSubtreeStream(adaptor,"rule multiplicativeOperator");
 17459  2276
         RewriteRuleSubtreeStream stream_unaryExpression=new RewriteRuleSubtreeStream(adaptor,"rule unaryExpression");
 17460  
         try {
 17461  
             // com\\googlecode\\sparkleg\\Sparql.g:522:5: ( (u1= unaryExpression -> $u1) ( multiplicativeOperator u2= unaryExpression -> ^( multiplicativeOperator $multiplicativeExpression $u2) )* )
 17462  
             // com\\googlecode\\sparkleg\\Sparql.g:522:7: (u1= unaryExpression -> $u1) ( multiplicativeOperator u2= unaryExpression -> ^( multiplicativeOperator $multiplicativeExpression $u2) )*
 17463  
             {
 17464  
             // com\\googlecode\\sparkleg\\Sparql.g:522:7: (u1= unaryExpression -> $u1)
 17465  
             // com\\googlecode\\sparkleg\\Sparql.g:522:8: u1= unaryExpression
 17466  
             {
 17467  2276
             pushFollow(FOLLOW_unaryExpression_in_multiplicativeExpression4821);
 17468  2276
             u1=unaryExpression();
 17469  
 
 17470  2276
             state._fsp--;
 17471  
 
 17472  2276
             stream_unaryExpression.add(u1.getTree());
 17473  
 
 17474  
             // AST REWRITE
 17475  
             // elements: u1
 17476  
             // token labels: 
 17477  
             // rule labels: retval, u1
 17478  
             // token list labels: 
 17479  
             // rule list labels: 
 17480  
             // wildcard labels: 
 17481  2276
             retval.tree = root_0;
 17482  2276
             RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 17483  2276
             RewriteRuleSubtreeStream stream_u1=new RewriteRuleSubtreeStream(adaptor,"rule u1",u1!=null?u1.tree:null);
 17484  
 
 17485  2276
             root_0 = (Object)adaptor.nil();
 17486  
             // 522:27: -> $u1
 17487  
             {
 17488  2276
                 adaptor.addChild(root_0, stream_u1.nextTree());
 17489  
 
 17490  
             }
 17491  
 
 17492  
 
 17493  2276
             retval.tree = root_0;
 17494  
 
 17495  
             }
 17496  
 
 17497  
 
 17498  
             // com\\googlecode\\sparkleg\\Sparql.g:522:35: ( multiplicativeOperator u2= unaryExpression -> ^( multiplicativeOperator $multiplicativeExpression $u2) )*
 17499  
             loop123:
 17500  
             do {
 17501  2308
                 int alt123=2;
 17502  2308
                 switch ( input.LA(1) ) {
 17503  
                 case ASTERISK:
 17504  
                 case DIVIDE:
 17505  
                     {
 17506  32
                     alt123=1;
 17507  
                     }
 17508  
                     break;
 17509  
 
 17510  
                 }
 17511  
 
 17512  2308
                 switch (alt123) {
 17513  
                     case 1 :
 17514  
                         // com\\googlecode\\sparkleg\\Sparql.g:522:36: multiplicativeOperator u2= unaryExpression
 17515  
                         {
 17516  32
                         pushFollow(FOLLOW_multiplicativeOperator_in_multiplicativeExpression4830);
 17517  32
                         multiplicativeOperator368=multiplicativeOperator();
 17518  
 
 17519  32
                         state._fsp--;
 17520  
 
 17521  32
                         stream_multiplicativeOperator.add(multiplicativeOperator368.getTree());
 17522  
 
 17523  32
                         pushFollow(FOLLOW_unaryExpression_in_multiplicativeExpression4834);
 17524  32
                         u2=unaryExpression();
 17525  
 
 17526  32
                         state._fsp--;
 17527  
 
 17528  32
                         stream_unaryExpression.add(u2.getTree());
 17529  
 
 17530  
                         // AST REWRITE
 17531  
                         // elements: multiplicativeOperator, multiplicativeExpression, u2
 17532  
                         // token labels: 
 17533  
                         // rule labels: retval, u2
 17534  
                         // token list labels: 
 17535  
                         // rule list labels: 
 17536  
                         // wildcard labels: 
 17537  32
                         retval.tree = root_0;
 17538  32
                         RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 17539  32
                         RewriteRuleSubtreeStream stream_u2=new RewriteRuleSubtreeStream(adaptor,"rule u2",u2!=null?u2.tree:null);
 17540  
 
 17541  32
                         root_0 = (Object)adaptor.nil();
 17542  
                         // 522:78: -> ^( multiplicativeOperator $multiplicativeExpression $u2)
 17543  
                         {
 17544  
                             // com\\googlecode\\sparkleg\\Sparql.g:522:81: ^( multiplicativeOperator $multiplicativeExpression $u2)
 17545  
                             {
 17546  32
                             Object root_1 = (Object)adaptor.nil();
 17547  32
                             root_1 = (Object)adaptor.becomeRoot(stream_multiplicativeOperator.nextNode(), root_1);
 17548  
 
 17549  32
                             adaptor.addChild(root_1, stream_retval.nextTree());
 17550  
 
 17551  32
                             adaptor.addChild(root_1, stream_u2.nextTree());
 17552  
 
 17553  32
                             adaptor.addChild(root_0, root_1);
 17554  
                             }
 17555  
 
 17556  
                         }
 17557  
 
 17558  
 
 17559  32
                         retval.tree = root_0;
 17560  
 
 17561  
                         }
 17562  32
                         break;
 17563  
 
 17564  
                     default :
 17565  2276
                         break loop123;
 17566  
                 }
 17567  32
             } while (true);
 17568  
 
 17569  
 
 17570  
             }
 17571  
 
 17572  2276
             retval.stop = input.LT(-1);
 17573  
 
 17574  
 
 17575  2276
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 17576  2276
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 17577  
 
 17578  
         }
 17579  0
         catch (RecognitionException re) {
 17580  0
             reportError(re);
 17581  0
             recover(input,re);
 17582  0
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 17583  
 
 17584  
         }
 17585  
 
 17586  0
         finally {
 17587  
                 // do for sure before leaving
 17588  2276
         }
 17589  2276
         return retval;
 17590  
     }
 17591  
     // $ANTLR end "multiplicativeExpression"
 17592  
 
 17593  
 
 17594  32
     public static class multiplicativeOperator_return extends ParserRuleReturnScope {
 17595  
         Object tree;
 17596  32
         public Object getTree() { return tree; }
 17597  
     };
 17598  
 
 17599  
 
 17600  
     // $ANTLR start "multiplicativeOperator"
 17601  
     // com\\googlecode\\sparkleg\\Sparql.g:525:1: multiplicativeOperator : ( ASTERISK | DIVIDE );
 17602  
     public final SparqlParser.multiplicativeOperator_return multiplicativeOperator() throws RecognitionException {
 17603  32
         SparqlParser.multiplicativeOperator_return retval = new SparqlParser.multiplicativeOperator_return();
 17604  32
         retval.start = input.LT(1);
 17605  
 
 17606  
 
 17607  32
         Object root_0 = null;
 17608  
 
 17609  32
         Token set369=null;
 17610  
 
 17611  32
         Object set369_tree=null;
 17612  
 
 17613  
         try {
 17614  
             // com\\googlecode\\sparkleg\\Sparql.g:526:5: ( ASTERISK | DIVIDE )
 17615  
             // com\\googlecode\\sparkleg\\Sparql.g:
 17616  
             {
 17617  32
             root_0 = (Object)adaptor.nil();
 17618  
 
 17619  
 
 17620  32
             set369=(Token)input.LT(1);
 17621  
 
 17622  32
             if ( input.LA(1)==ASTERISK||input.LA(1)==DIVIDE ) {
 17623  32
                 input.consume();
 17624  32
                 adaptor.addChild(root_0, 
 17625  
                 (Object)adaptor.create(set369)
 17626  
                 );
 17627  32
                 state.errorRecovery=false;
 17628  
             }
 17629  
             else {
 17630  0
                 MismatchedSetException mse = new MismatchedSetException(null,input);
 17631  0
                 throw mse;
 17632  
             }
 17633  
 
 17634  
 
 17635  
             }
 17636  
 
 17637  32
             retval.stop = input.LT(-1);
 17638  
 
 17639  
 
 17640  32
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 17641  32
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 17642  
 
 17643  
         }
 17644  0
         catch (RecognitionException re) {
 17645  0
             reportError(re);
 17646  0
             recover(input,re);
 17647  0
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 17648  
 
 17649  
         }
 17650  
 
 17651  0
         finally {
 17652  
                 // do for sure before leaving
 17653  32
         }
 17654  32
         return retval;
 17655  
     }
 17656  
     // $ANTLR end "multiplicativeOperator"
 17657  
 
 17658  
 
 17659  2308
     public static class unaryExpression_return extends ParserRuleReturnScope {
 17660  
         Object tree;
 17661  2308
         public Object getTree() { return tree; }
 17662  
     };
 17663  
 
 17664  
 
 17665  
     // $ANTLR start "unaryExpression"
 17666  
     // com\\googlecode\\sparkleg\\Sparql.g:529:1: unaryExpression : ( NEGATION primaryExpression -> ^( UNARY NEGATION primaryExpression ) | PLUS primaryExpression -> ^( UNARY PLUS primaryExpression ) | MINUS primaryExpression -> ^( UNARY MINUS primaryExpression ) | primaryExpression -> ^( UNARY primaryExpression ) );
 17667  
     public final SparqlParser.unaryExpression_return unaryExpression() throws RecognitionException {
 17668  2308
         SparqlParser.unaryExpression_return retval = new SparqlParser.unaryExpression_return();
 17669  2308
         retval.start = input.LT(1);
 17670  
 
 17671  
 
 17672  2308
         Object root_0 = null;
 17673  
 
 17674  2308
         Token NEGATION370=null;
 17675  2308
         Token PLUS372=null;
 17676  2308
         Token MINUS374=null;
 17677  2308
         SparqlParser.primaryExpression_return primaryExpression371 =null;
 17678  
 
 17679  2308
         SparqlParser.primaryExpression_return primaryExpression373 =null;
 17680  
 
 17681  2308
         SparqlParser.primaryExpression_return primaryExpression375 =null;
 17682  
 
 17683  2308
         SparqlParser.primaryExpression_return primaryExpression376 =null;
 17684  
 
 17685  
 
 17686  2308
         Object NEGATION370_tree=null;
 17687  2308
         Object PLUS372_tree=null;
 17688  2308
         Object MINUS374_tree=null;
 17689  2308
         RewriteRuleTokenStream stream_PLUS=new RewriteRuleTokenStream(adaptor,"token PLUS");
 17690  2308
         RewriteRuleTokenStream stream_NEGATION=new RewriteRuleTokenStream(adaptor,"token NEGATION");
 17691  2308
         RewriteRuleTokenStream stream_MINUS=new RewriteRuleTokenStream(adaptor,"token MINUS");
 17692  2308
         RewriteRuleSubtreeStream stream_primaryExpression=new RewriteRuleSubtreeStream(adaptor,"rule primaryExpression");
 17693  
         try {
 17694  
             // com\\googlecode\\sparkleg\\Sparql.g:530:5: ( NEGATION primaryExpression -> ^( UNARY NEGATION primaryExpression ) | PLUS primaryExpression -> ^( UNARY PLUS primaryExpression ) | MINUS primaryExpression -> ^( UNARY MINUS primaryExpression ) | primaryExpression -> ^( UNARY primaryExpression ) )
 17695  2308
             int alt124=4;
 17696  2308
             switch ( input.LA(1) ) {
 17697  
             case NEGATION:
 17698  
                 {
 17699  38
                 alt124=1;
 17700  
                 }
 17701  38
                 break;
 17702  
             case PLUS:
 17703  
                 {
 17704  0
                 alt124=2;
 17705  
                 }
 17706  0
                 break;
 17707  
             case MINUS:
 17708  
                 {
 17709  2
                 alt124=3;
 17710  
                 }
 17711  2
                 break;
 17712  
             case ABS:
 17713  
             case AVG:
 17714  
             case BNODE:
 17715  
             case BOUND:
 17716  
             case CEIL:
 17717  
             case COALESCE:
 17718  
             case CONCAT:
 17719  
             case CONTAINS:
 17720  
             case COUNT:
 17721  
             case DATATYPE:
 17722  
             case DAY:
 17723  
             case DECIMAL:
 17724  
             case DECIMAL_NEGATIVE:
 17725  
             case DECIMAL_POSITIVE:
 17726  
             case DOUBLE:
 17727  
             case DOUBLE_NEGATIVE:
 17728  
             case DOUBLE_POSITIVE:
 17729  
             case ENCODE_FOR_URI:
 17730  
             case EXISTS:
 17731  
             case FALSE:
 17732  
             case FLOOR:
 17733  
             case GROUP_CONCAT:
 17734  
             case HOURS:
 17735  
             case IF:
 17736  
             case INTEGER:
 17737  
             case INTEGER_NEGATIVE:
 17738  
             case INTEGER_POSITIVE:
 17739  
             case IRI:
 17740  
             case IRI_REF:
 17741  
             case ISBLANK:
 17742  
             case ISIRI:
 17743  
             case ISLITERAL:
 17744  
             case ISNUMERIC:
 17745  
             case ISURI:
 17746  
             case LANG:
 17747  
             case LANGMATCHES:
 17748  
             case LCASE:
 17749  
             case MAX:
 17750  
             case MD5:
 17751  
             case MIN:
 17752  
             case MINUTES:
 17753  
             case MONTH:
 17754  
             case NOT:
 17755  
             case NOW:
 17756  
             case OPEN_BRACE:
 17757  
             case PNAME_LN:
 17758  
             case PNAME_NS:
 17759  
             case RAND:
 17760  
             case REGEX:
 17761  
             case REPLACE:
 17762  
             case ROUND:
 17763  
             case SAMETERM:
 17764  
             case SAMPLE:
 17765  
             case SECONDS:
 17766  
             case SHA1:
 17767  
             case SHA224:
 17768  
             case SHA256:
 17769  
             case SHA384:
 17770  
             case SHA512:
 17771  
             case STR:
 17772  
             case STRAFTER:
 17773  
             case STRBEFORE:
 17774  
             case STRDT:
 17775  
             case STRENDS:
 17776  
             case STRING_LITERAL1:
 17777  
             case STRING_LITERAL2:
 17778  
             case STRING_LITERAL_LONG1:
 17779  
             case STRING_LITERAL_LONG2:
 17780  
             case STRLANG:
 17781  
             case STRLEN:
 17782  
             case STRSTARTS:
 17783  
             case SUBSTR:
 17784  
             case SUM:
 17785  
             case TIMEZONE:
 17786  
             case TRUE:
 17787  
             case TZ:
 17788  
             case UCASE:
 17789  
             case URI:
 17790  
             case VAR1:
 17791  
             case VAR2:
 17792  
             case YEAR:
 17793  
                 {
 17794  2268
                 alt124=4;
 17795  
                 }
 17796  2268
                 break;
 17797  
             default:
 17798  0
                 NoViableAltException nvae =
 17799  
                     new NoViableAltException("", 124, 0, input);
 17800  
 
 17801  0
                 throw nvae;
 17802  
 
 17803  
             }
 17804  
 
 17805  2308
             switch (alt124) {
 17806  
                 case 1 :
 17807  
                     // com\\googlecode\\sparkleg\\Sparql.g:530:7: NEGATION primaryExpression
 17808  
                     {
 17809  38
                     NEGATION370=(Token)match(input,NEGATION,FOLLOW_NEGATION_in_unaryExpression4890);  
 17810  38
                     stream_NEGATION.add(NEGATION370);
 17811  
 
 17812  
 
 17813  38
                     pushFollow(FOLLOW_primaryExpression_in_unaryExpression4892);
 17814  38
                     primaryExpression371=primaryExpression();
 17815  
 
 17816  38
                     state._fsp--;
 17817  
 
 17818  38
                     stream_primaryExpression.add(primaryExpression371.getTree());
 17819  
 
 17820  
                     // AST REWRITE
 17821  
                     // elements: NEGATION, primaryExpression
 17822  
                     // token labels: 
 17823  
                     // rule labels: retval
 17824  
                     // token list labels: 
 17825  
                     // rule list labels: 
 17826  
                     // wildcard labels: 
 17827  38
                     retval.tree = root_0;
 17828  38
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 17829  
 
 17830  38
                     root_0 = (Object)adaptor.nil();
 17831  
                     // 530:34: -> ^( UNARY NEGATION primaryExpression )
 17832  
                     {
 17833  
                         // com\\googlecode\\sparkleg\\Sparql.g:530:37: ^( UNARY NEGATION primaryExpression )
 17834  
                         {
 17835  38
                         Object root_1 = (Object)adaptor.nil();
 17836  38
                         root_1 = (Object)adaptor.becomeRoot(
 17837  
                         (Object)adaptor.create(UNARY, "UNARY")
 17838  
                         , root_1);
 17839  
 
 17840  38
                         adaptor.addChild(root_1, 
 17841  
                         stream_NEGATION.nextNode()
 17842  
                         );
 17843  
 
 17844  38
                         adaptor.addChild(root_1, stream_primaryExpression.nextTree());
 17845  
 
 17846  38
                         adaptor.addChild(root_0, root_1);
 17847  
                         }
 17848  
 
 17849  
                     }
 17850  
 
 17851  
 
 17852  38
                     retval.tree = root_0;
 17853  
 
 17854  
                     }
 17855  38
                     break;
 17856  
                 case 2 :
 17857  
                     // com\\googlecode\\sparkleg\\Sparql.g:531:7: PLUS primaryExpression
 17858  
                     {
 17859  0
                     PLUS372=(Token)match(input,PLUS,FOLLOW_PLUS_in_unaryExpression4910);  
 17860  0
                     stream_PLUS.add(PLUS372);
 17861  
 
 17862  
 
 17863  0
                     pushFollow(FOLLOW_primaryExpression_in_unaryExpression4912);
 17864  0
                     primaryExpression373=primaryExpression();
 17865  
 
 17866  0
                     state._fsp--;
 17867  
 
 17868  0
                     stream_primaryExpression.add(primaryExpression373.getTree());
 17869  
 
 17870  
                     // AST REWRITE
 17871  
                     // elements: PLUS, primaryExpression
 17872  
                     // token labels: 
 17873  
                     // rule labels: retval
 17874  
                     // token list labels: 
 17875  
                     // rule list labels: 
 17876  
                     // wildcard labels: 
 17877  0
                     retval.tree = root_0;
 17878  0
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 17879  
 
 17880  0
                     root_0 = (Object)adaptor.nil();
 17881  
                     // 531:30: -> ^( UNARY PLUS primaryExpression )
 17882  
                     {
 17883  
                         // com\\googlecode\\sparkleg\\Sparql.g:531:33: ^( UNARY PLUS primaryExpression )
 17884  
                         {
 17885  0
                         Object root_1 = (Object)adaptor.nil();
 17886  0
                         root_1 = (Object)adaptor.becomeRoot(
 17887  
                         (Object)adaptor.create(UNARY, "UNARY")
 17888  
                         , root_1);
 17889  
 
 17890  0
                         adaptor.addChild(root_1, 
 17891  
                         stream_PLUS.nextNode()
 17892  
                         );
 17893  
 
 17894  0
                         adaptor.addChild(root_1, stream_primaryExpression.nextTree());
 17895  
 
 17896  0
                         adaptor.addChild(root_0, root_1);
 17897  
                         }
 17898  
 
 17899  
                     }
 17900  
 
 17901  
 
 17902  0
                     retval.tree = root_0;
 17903  
 
 17904  
                     }
 17905  0
                     break;
 17906  
                 case 3 :
 17907  
                     // com\\googlecode\\sparkleg\\Sparql.g:532:7: MINUS primaryExpression
 17908  
                     {
 17909  2
                     MINUS374=(Token)match(input,MINUS,FOLLOW_MINUS_in_unaryExpression4930);  
 17910  2
                     stream_MINUS.add(MINUS374);
 17911  
 
 17912  
 
 17913  2
                     pushFollow(FOLLOW_primaryExpression_in_unaryExpression4932);
 17914  2
                     primaryExpression375=primaryExpression();
 17915  
 
 17916  2
                     state._fsp--;
 17917  
 
 17918  2
                     stream_primaryExpression.add(primaryExpression375.getTree());
 17919  
 
 17920  
                     // AST REWRITE
 17921  
                     // elements: MINUS, primaryExpression
 17922  
                     // token labels: 
 17923  
                     // rule labels: retval
 17924  
                     // token list labels: 
 17925  
                     // rule list labels: 
 17926  
                     // wildcard labels: 
 17927  2
                     retval.tree = root_0;
 17928  2
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 17929  
 
 17930  2
                     root_0 = (Object)adaptor.nil();
 17931  
                     // 532:31: -> ^( UNARY MINUS primaryExpression )
 17932  
                     {
 17933  
                         // com\\googlecode\\sparkleg\\Sparql.g:532:34: ^( UNARY MINUS primaryExpression )
 17934  
                         {
 17935  2
                         Object root_1 = (Object)adaptor.nil();
 17936  2
                         root_1 = (Object)adaptor.becomeRoot(
 17937  
                         (Object)adaptor.create(UNARY, "UNARY")
 17938  
                         , root_1);
 17939  
 
 17940  2
                         adaptor.addChild(root_1, 
 17941  
                         stream_MINUS.nextNode()
 17942  
                         );
 17943  
 
 17944  2
                         adaptor.addChild(root_1, stream_primaryExpression.nextTree());
 17945  
 
 17946  2
                         adaptor.addChild(root_0, root_1);
 17947  
                         }
 17948  
 
 17949  
                     }
 17950  
 
 17951  
 
 17952  2
                     retval.tree = root_0;
 17953  
 
 17954  
                     }
 17955  2
                     break;
 17956  
                 case 4 :
 17957  
                     // com\\googlecode\\sparkleg\\Sparql.g:533:7: primaryExpression
 17958  
                     {
 17959  2268
                     pushFollow(FOLLOW_primaryExpression_in_unaryExpression4950);
 17960  2268
                     primaryExpression376=primaryExpression();
 17961  
 
 17962  2268
                     state._fsp--;
 17963  
 
 17964  2268
                     stream_primaryExpression.add(primaryExpression376.getTree());
 17965  
 
 17966  
                     // AST REWRITE
 17967  
                     // elements: primaryExpression
 17968  
                     // token labels: 
 17969  
                     // rule labels: retval
 17970  
                     // token list labels: 
 17971  
                     // rule list labels: 
 17972  
                     // wildcard labels: 
 17973  2268
                     retval.tree = root_0;
 17974  2268
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 17975  
 
 17976  2268
                     root_0 = (Object)adaptor.nil();
 17977  
                     // 533:25: -> ^( UNARY primaryExpression )
 17978  
                     {
 17979  
                         // com\\googlecode\\sparkleg\\Sparql.g:533:28: ^( UNARY primaryExpression )
 17980  
                         {
 17981  2268
                         Object root_1 = (Object)adaptor.nil();
 17982  2268
                         root_1 = (Object)adaptor.becomeRoot(
 17983  
                         (Object)adaptor.create(UNARY, "UNARY")
 17984  
                         , root_1);
 17985  
 
 17986  2268
                         adaptor.addChild(root_1, stream_primaryExpression.nextTree());
 17987  
 
 17988  2268
                         adaptor.addChild(root_0, root_1);
 17989  
                         }
 17990  
 
 17991  
                     }
 17992  
 
 17993  
 
 17994  2268
                     retval.tree = root_0;
 17995  
 
 17996  
                     }
 17997  
                     break;
 17998  
 
 17999  
             }
 18000  2308
             retval.stop = input.LT(-1);
 18001  
 
 18002  
 
 18003  2308
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 18004  2308
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 18005  
 
 18006  
         }
 18007  0
         catch (RecognitionException re) {
 18008  0
             reportError(re);
 18009  0
             recover(input,re);
 18010  0
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 18011  
 
 18012  
         }
 18013  
 
 18014  0
         finally {
 18015  
                 // do for sure before leaving
 18016  2308
         }
 18017  2308
         return retval;
 18018  
     }
 18019  
     // $ANTLR end "unaryExpression"
 18020  
 
 18021  
 
 18022  2308
     public static class primaryExpression_return extends ParserRuleReturnScope {
 18023  
         Object tree;
 18024  2308
         public Object getTree() { return tree; }
 18025  
     };
 18026  
 
 18027  
 
 18028  
     // $ANTLR start "primaryExpression"
 18029  
     // com\\googlecode\\sparkleg\\Sparql.g:536:1: primaryExpression : ( brackettedExpression | builtInCall | iriRefOrFunction | rdfLiteral | numericLiteral | booleanLiteral | var | aggregate );
 18030  
     public final SparqlParser.primaryExpression_return primaryExpression() throws RecognitionException {
 18031  2308
         SparqlParser.primaryExpression_return retval = new SparqlParser.primaryExpression_return();
 18032  2308
         retval.start = input.LT(1);
 18033  
 
 18034  
 
 18035  2308
         Object root_0 = null;
 18036  
 
 18037  2308
         SparqlParser.brackettedExpression_return brackettedExpression377 =null;
 18038  
 
 18039  2308
         SparqlParser.builtInCall_return builtInCall378 =null;
 18040  
 
 18041  2308
         SparqlParser.iriRefOrFunction_return iriRefOrFunction379 =null;
 18042  
 
 18043  2308
         SparqlParser.rdfLiteral_return rdfLiteral380 =null;
 18044  
 
 18045  2308
         SparqlParser.numericLiteral_return numericLiteral381 =null;
 18046  
 
 18047  2308
         SparqlParser.booleanLiteral_return booleanLiteral382 =null;
 18048  
 
 18049  2308
         SparqlParser.var_return var383 =null;
 18050  
 
 18051  2308
         SparqlParser.aggregate_return aggregate384 =null;
 18052  
 
 18053  
 
 18054  
 
 18055  
         try {
 18056  
             // com\\googlecode\\sparkleg\\Sparql.g:537:5: ( brackettedExpression | builtInCall | iriRefOrFunction | rdfLiteral | numericLiteral | booleanLiteral | var | aggregate )
 18057  2308
             int alt125=8;
 18058  2308
             switch ( input.LA(1) ) {
 18059  
             case OPEN_BRACE:
 18060  
                 {
 18061  48
                 alt125=1;
 18062  
                 }
 18063  48
                 break;
 18064  
             case ABS:
 18065  
             case BNODE:
 18066  
             case BOUND:
 18067  
             case CEIL:
 18068  
             case COALESCE:
 18069  
             case CONCAT:
 18070  
             case CONTAINS:
 18071  
             case DATATYPE:
 18072  
             case DAY:
 18073  
             case ENCODE_FOR_URI:
 18074  
             case EXISTS:
 18075  
             case FLOOR:
 18076  
             case HOURS:
 18077  
             case IF:
 18078  
             case IRI:
 18079  
             case ISBLANK:
 18080  
             case ISIRI:
 18081  
             case ISLITERAL:
 18082  
             case ISNUMERIC:
 18083  
             case ISURI:
 18084  
             case LANG:
 18085  
             case LANGMATCHES:
 18086  
             case LCASE:
 18087  
             case MD5:
 18088  
             case MINUTES:
 18089  
             case MONTH:
 18090  
             case NOT:
 18091  
             case NOW:
 18092  
             case RAND:
 18093  
             case REGEX:
 18094  
             case REPLACE:
 18095  
             case ROUND:
 18096  
             case SAMETERM:
 18097  
             case SECONDS:
 18098  
             case SHA1:
 18099  
             case SHA224:
 18100  
             case SHA256:
 18101  
             case SHA384:
 18102  
             case SHA512:
 18103  
             case STR:
 18104  
             case STRAFTER:
 18105  
             case STRBEFORE:
 18106  
             case STRDT:
 18107  
             case STRENDS:
 18108  
             case STRLANG:
 18109  
             case STRLEN:
 18110  
             case STRSTARTS:
 18111  
             case SUBSTR:
 18112  
             case TIMEZONE:
 18113  
             case TZ:
 18114  
             case UCASE:
 18115  
             case URI:
 18116  
             case YEAR:
 18117  
                 {
 18118  374
                 alt125=2;
 18119  
                 }
 18120  374
                 break;
 18121  
             case IRI_REF:
 18122  
             case PNAME_LN:
 18123  
             case PNAME_NS:
 18124  
                 {
 18125  178
                 alt125=3;
 18126  
                 }
 18127  178
                 break;
 18128  
             case STRING_LITERAL1:
 18129  
             case STRING_LITERAL2:
 18130  
             case STRING_LITERAL_LONG1:
 18131  
             case STRING_LITERAL_LONG2:
 18132  
                 {
 18133  208
                 alt125=4;
 18134  
                 }
 18135  208
                 break;
 18136  
             case DECIMAL:
 18137  
             case DECIMAL_NEGATIVE:
 18138  
             case DECIMAL_POSITIVE:
 18139  
             case DOUBLE:
 18140  
             case DOUBLE_NEGATIVE:
 18141  
             case DOUBLE_POSITIVE:
 18142  
             case INTEGER:
 18143  
             case INTEGER_NEGATIVE:
 18144  
             case INTEGER_POSITIVE:
 18145  
                 {
 18146  206
                 alt125=5;
 18147  
                 }
 18148  206
                 break;
 18149  
             case FALSE:
 18150  
             case TRUE:
 18151  
                 {
 18152  12
                 alt125=6;
 18153  
                 }
 18154  12
                 break;
 18155  
             case VAR1:
 18156  
             case VAR2:
 18157  
                 {
 18158  1176
                 alt125=7;
 18159  
                 }
 18160  1176
                 break;
 18161  
             case AVG:
 18162  
             case COUNT:
 18163  
             case GROUP_CONCAT:
 18164  
             case MAX:
 18165  
             case MIN:
 18166  
             case SAMPLE:
 18167  
             case SUM:
 18168  
                 {
 18169  106
                 alt125=8;
 18170  
                 }
 18171  106
                 break;
 18172  
             default:
 18173  0
                 NoViableAltException nvae =
 18174  
                     new NoViableAltException("", 125, 0, input);
 18175  
 
 18176  0
                 throw nvae;
 18177  
 
 18178  
             }
 18179  
 
 18180  2308
             switch (alt125) {
 18181  
                 case 1 :
 18182  
                     // com\\googlecode\\sparkleg\\Sparql.g:537:7: brackettedExpression
 18183  
                     {
 18184  48
                     root_0 = (Object)adaptor.nil();
 18185  
 
 18186  
 
 18187  48
                     pushFollow(FOLLOW_brackettedExpression_in_primaryExpression4975);
 18188  48
                     brackettedExpression377=brackettedExpression();
 18189  
 
 18190  48
                     state._fsp--;
 18191  
 
 18192  48
                     adaptor.addChild(root_0, brackettedExpression377.getTree());
 18193  
 
 18194  
                     }
 18195  48
                     break;
 18196  
                 case 2 :
 18197  
                     // com\\googlecode\\sparkleg\\Sparql.g:537:30: builtInCall
 18198  
                     {
 18199  374
                     root_0 = (Object)adaptor.nil();
 18200  
 
 18201  
 
 18202  374
                     pushFollow(FOLLOW_builtInCall_in_primaryExpression4979);
 18203  374
                     builtInCall378=builtInCall();
 18204  
 
 18205  374
                     state._fsp--;
 18206  
 
 18207  374
                     adaptor.addChild(root_0, builtInCall378.getTree());
 18208  
 
 18209  
                     }
 18210  374
                     break;
 18211  
                 case 3 :
 18212  
                     // com\\googlecode\\sparkleg\\Sparql.g:537:44: iriRefOrFunction
 18213  
                     {
 18214  178
                     root_0 = (Object)adaptor.nil();
 18215  
 
 18216  
 
 18217  178
                     pushFollow(FOLLOW_iriRefOrFunction_in_primaryExpression4983);
 18218  178
                     iriRefOrFunction379=iriRefOrFunction();
 18219  
 
 18220  178
                     state._fsp--;
 18221  
 
 18222  178
                     adaptor.addChild(root_0, iriRefOrFunction379.getTree());
 18223  
 
 18224  
                     }
 18225  178
                     break;
 18226  
                 case 4 :
 18227  
                     // com\\googlecode\\sparkleg\\Sparql.g:537:63: rdfLiteral
 18228  
                     {
 18229  208
                     root_0 = (Object)adaptor.nil();
 18230  
 
 18231  
 
 18232  208
                     pushFollow(FOLLOW_rdfLiteral_in_primaryExpression4987);
 18233  208
                     rdfLiteral380=rdfLiteral();
 18234  
 
 18235  208
                     state._fsp--;
 18236  
 
 18237  208
                     adaptor.addChild(root_0, rdfLiteral380.getTree());
 18238  
 
 18239  
                     }
 18240  208
                     break;
 18241  
                 case 5 :
 18242  
                     // com\\googlecode\\sparkleg\\Sparql.g:537:76: numericLiteral
 18243  
                     {
 18244  206
                     root_0 = (Object)adaptor.nil();
 18245  
 
 18246  
 
 18247  206
                     pushFollow(FOLLOW_numericLiteral_in_primaryExpression4991);
 18248  206
                     numericLiteral381=numericLiteral();
 18249  
 
 18250  206
                     state._fsp--;
 18251  
 
 18252  206
                     adaptor.addChild(root_0, numericLiteral381.getTree());
 18253  
 
 18254  
                     }
 18255  206
                     break;
 18256  
                 case 6 :
 18257  
                     // com\\googlecode\\sparkleg\\Sparql.g:537:93: booleanLiteral
 18258  
                     {
 18259  12
                     root_0 = (Object)adaptor.nil();
 18260  
 
 18261  
 
 18262  12
                     pushFollow(FOLLOW_booleanLiteral_in_primaryExpression4995);
 18263  12
                     booleanLiteral382=booleanLiteral();
 18264  
 
 18265  12
                     state._fsp--;
 18266  
 
 18267  12
                     adaptor.addChild(root_0, booleanLiteral382.getTree());
 18268  
 
 18269  
                     }
 18270  12
                     break;
 18271  
                 case 7 :
 18272  
                     // com\\googlecode\\sparkleg\\Sparql.g:537:110: var
 18273  
                     {
 18274  1176
                     root_0 = (Object)adaptor.nil();
 18275  
 
 18276  
 
 18277  1176
                     pushFollow(FOLLOW_var_in_primaryExpression4999);
 18278  1176
                     var383=var();
 18279  
 
 18280  1176
                     state._fsp--;
 18281  
 
 18282  1176
                     adaptor.addChild(root_0, var383.getTree());
 18283  
 
 18284  
                     }
 18285  1176
                     break;
 18286  
                 case 8 :
 18287  
                     // com\\googlecode\\sparkleg\\Sparql.g:537:116: aggregate
 18288  
                     {
 18289  106
                     root_0 = (Object)adaptor.nil();
 18290  
 
 18291  
 
 18292  106
                     pushFollow(FOLLOW_aggregate_in_primaryExpression5003);
 18293  106
                     aggregate384=aggregate();
 18294  
 
 18295  106
                     state._fsp--;
 18296  
 
 18297  106
                     adaptor.addChild(root_0, aggregate384.getTree());
 18298  
 
 18299  
                     }
 18300  
                     break;
 18301  
 
 18302  
             }
 18303  2308
             retval.stop = input.LT(-1);
 18304  
 
 18305  
 
 18306  2308
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 18307  2308
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 18308  
 
 18309  
         }
 18310  0
         catch (RecognitionException re) {
 18311  0
             reportError(re);
 18312  0
             recover(input,re);
 18313  0
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 18314  
 
 18315  
         }
 18316  
 
 18317  0
         finally {
 18318  
                 // do for sure before leaving
 18319  2308
         }
 18320  2308
         return retval;
 18321  
     }
 18322  
     // $ANTLR end "primaryExpression"
 18323  
 
 18324  
 
 18325  534
     public static class brackettedExpression_return extends ParserRuleReturnScope {
 18326  
         Object tree;
 18327  534
         public Object getTree() { return tree; }
 18328  
     };
 18329  
 
 18330  
 
 18331  
     // $ANTLR start "brackettedExpression"
 18332  
     // com\\googlecode\\sparkleg\\Sparql.g:540:1: brackettedExpression : OPEN_BRACE expression CLOSE_BRACE -> ^( BRACKETTED_EXPRESSION expression ) ;
 18333  
     public final SparqlParser.brackettedExpression_return brackettedExpression() throws RecognitionException {
 18334  534
         SparqlParser.brackettedExpression_return retval = new SparqlParser.brackettedExpression_return();
 18335  534
         retval.start = input.LT(1);
 18336  
 
 18337  
 
 18338  534
         Object root_0 = null;
 18339  
 
 18340  534
         Token OPEN_BRACE385=null;
 18341  534
         Token CLOSE_BRACE387=null;
 18342  534
         SparqlParser.expression_return expression386 =null;
 18343  
 
 18344  
 
 18345  534
         Object OPEN_BRACE385_tree=null;
 18346  534
         Object CLOSE_BRACE387_tree=null;
 18347  534
         RewriteRuleTokenStream stream_CLOSE_BRACE=new RewriteRuleTokenStream(adaptor,"token CLOSE_BRACE");
 18348  534
         RewriteRuleTokenStream stream_OPEN_BRACE=new RewriteRuleTokenStream(adaptor,"token OPEN_BRACE");
 18349  534
         RewriteRuleSubtreeStream stream_expression=new RewriteRuleSubtreeStream(adaptor,"rule expression");
 18350  
         try {
 18351  
             // com\\googlecode\\sparkleg\\Sparql.g:541:5: ( OPEN_BRACE expression CLOSE_BRACE -> ^( BRACKETTED_EXPRESSION expression ) )
 18352  
             // com\\googlecode\\sparkleg\\Sparql.g:541:7: OPEN_BRACE expression CLOSE_BRACE
 18353  
             {
 18354  534
             OPEN_BRACE385=(Token)match(input,OPEN_BRACE,FOLLOW_OPEN_BRACE_in_brackettedExpression5020);  
 18355  534
             stream_OPEN_BRACE.add(OPEN_BRACE385);
 18356  
 
 18357  
 
 18358  534
             pushFollow(FOLLOW_expression_in_brackettedExpression5022);
 18359  534
             expression386=expression();
 18360  
 
 18361  534
             state._fsp--;
 18362  
 
 18363  534
             stream_expression.add(expression386.getTree());
 18364  
 
 18365  534
             CLOSE_BRACE387=(Token)match(input,CLOSE_BRACE,FOLLOW_CLOSE_BRACE_in_brackettedExpression5024);  
 18366  534
             stream_CLOSE_BRACE.add(CLOSE_BRACE387);
 18367  
 
 18368  
 
 18369  
             // AST REWRITE
 18370  
             // elements: expression
 18371  
             // token labels: 
 18372  
             // rule labels: retval
 18373  
             // token list labels: 
 18374  
             // rule list labels: 
 18375  
             // wildcard labels: 
 18376  534
             retval.tree = root_0;
 18377  534
             RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 18378  
 
 18379  534
             root_0 = (Object)adaptor.nil();
 18380  
             // 541:41: -> ^( BRACKETTED_EXPRESSION expression )
 18381  
             {
 18382  
                 // com\\googlecode\\sparkleg\\Sparql.g:541:44: ^( BRACKETTED_EXPRESSION expression )
 18383  
                 {
 18384  534
                 Object root_1 = (Object)adaptor.nil();
 18385  534
                 root_1 = (Object)adaptor.becomeRoot(
 18386  
                 (Object)adaptor.create(BRACKETTED_EXPRESSION, "BRACKETTED_EXPRESSION")
 18387  
                 , root_1);
 18388  
 
 18389  534
                 adaptor.addChild(root_1, stream_expression.nextTree());
 18390  
 
 18391  534
                 adaptor.addChild(root_0, root_1);
 18392  
                 }
 18393  
 
 18394  
             }
 18395  
 
 18396  
 
 18397  534
             retval.tree = root_0;
 18398  
 
 18399  
             }
 18400  
 
 18401  534
             retval.stop = input.LT(-1);
 18402  
 
 18403  
 
 18404  534
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 18405  534
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 18406  
 
 18407  
         }
 18408  0
         catch (RecognitionException re) {
 18409  0
             reportError(re);
 18410  0
             recover(input,re);
 18411  0
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 18412  
 
 18413  
         }
 18414  
 
 18415  0
         finally {
 18416  
                 // do for sure before leaving
 18417  534
         }
 18418  534
         return retval;
 18419  
     }
 18420  
     // $ANTLR end "brackettedExpression"
 18421  
 
 18422  
 
 18423  532
     public static class builtInCall_return extends ParserRuleReturnScope {
 18424  
         Object tree;
 18425  532
         public Object getTree() { return tree; }
 18426  
     };
 18427  
 
 18428  
 
 18429  
     // $ANTLR start "builtInCall"
 18430  
     // com\\googlecode\\sparkleg\\Sparql.g:544:1: builtInCall : ( STR OPEN_BRACE expression CLOSE_BRACE -> ^( STR expression ) | LANG OPEN_BRACE expression CLOSE_BRACE -> ^( LANG expression ) | LANGMATCHES OPEN_BRACE expression COMMA expression CLOSE_BRACE -> ^( LANGMATCHES ( expression )+ ) | DATATYPE OPEN_BRACE expression CLOSE_BRACE -> ^( DATATYPE expression ) | BOUND OPEN_BRACE var CLOSE_BRACE -> ^( BOUND var ) | IRI OPEN_BRACE expression CLOSE_BRACE -> ^( IRI expression ) | URI OPEN_BRACE expression CLOSE_BRACE -> ^( URI expression ) | BNODE ( OPEN_BRACE expression CLOSE_BRACE ) -> ^( BNODE expression ) | BNODE nil -> BNODE | RAND nil -> RAND | ABS OPEN_BRACE expression CLOSE_BRACE -> ^( ABS expression ) | CEIL OPEN_BRACE expression CLOSE_BRACE -> ^( CEIL expression ) | FLOOR OPEN_BRACE expression CLOSE_BRACE -> ^( FLOOR expression ) | ROUND OPEN_BRACE expression CLOSE_BRACE -> ^( ROUND expression ) | CONCAT expressionList -> ^( CONCAT expressionList ) | subStringExpression -> subStringExpression | STRLEN OPEN_BRACE expression CLOSE_BRACE -> ^( STRLEN expression ) | UCASE OPEN_BRACE expression CLOSE_BRACE -> ^( UCASE expression ) | LCASE OPEN_BRACE expression CLOSE_BRACE -> ^( LCASE expression ) | ENCODE_FOR_URI OPEN_BRACE expression CLOSE_BRACE -> ^( ENCODE_FOR_URI expression ) | CONTAINS OPEN_BRACE expression COMMA expression CLOSE_BRACE -> ^( CONTAINS expression expression ) | STRSTARTS OPEN_BRACE expression COMMA expression CLOSE_BRACE -> ^( STRSTARTS expression expression ) | STRENDS OPEN_BRACE expression COMMA expression CLOSE_BRACE -> ^( STRENDS expression expression ) | STRBEFORE OPEN_BRACE expression COMMA expression CLOSE_BRACE -> ^( STRBEFORE expression expression ) | STRAFTER OPEN_BRACE expression COMMA expression CLOSE_BRACE -> ^( STRAFTER expression expression ) | REPLACE OPEN_BRACE expression COMMA expression COMMA expression CLOSE_BRACE -> ^( REPLACE expression expression expression ) | YEAR OPEN_BRACE expression CLOSE_BRACE -> ^( YEAR expression ) | MONTH OPEN_BRACE expression CLOSE_BRACE -> ^( MONTH expression ) | DAY OPEN_BRACE expression CLOSE_BRACE -> ^( DAY expression ) | HOURS OPEN_BRACE expression CLOSE_BRACE -> ^( HOURS expression ) | MINUTES OPEN_BRACE expression CLOSE_BRACE -> ^( MINUTES expression ) | SECONDS OPEN_BRACE expression CLOSE_BRACE -> ^( SECONDS expression ) | TIMEZONE OPEN_BRACE expression CLOSE_BRACE -> ^( TIMEZONE expression ) | TZ OPEN_BRACE expression CLOSE_BRACE -> ^( TZ expression ) | NOW nil -> NOW | MD5 OPEN_BRACE expression CLOSE_BRACE -> ^( MD5 expression ) | SHA1 OPEN_BRACE expression CLOSE_BRACE -> ^( SHA1 expression ) | SHA224 OPEN_BRACE expression CLOSE_BRACE -> ^( SHA224 expression ) | SHA256 OPEN_BRACE expression CLOSE_BRACE -> ^( SHA256 expression ) | SHA384 OPEN_BRACE expression CLOSE_BRACE -> ^( SHA384 expression ) | SHA512 OPEN_BRACE expression CLOSE_BRACE -> ^( SHA512 expression ) | COALESCE expressionList -> ^( COALESCE expressionList ) | IF OPEN_BRACE e1= expression COMMA e2= expression COMMA e3= expression CLOSE_BRACE -> ^( IF $e1 $e2 $e3) | STRLANG OPEN_BRACE expression COMMA expression CLOSE_BRACE -> ^( STRLANG expression expression ) | STRDT OPEN_BRACE expression COMMA expression CLOSE_BRACE -> ^( STRDT expression expression ) | SAMETERM OPEN_BRACE expression COMMA expression CLOSE_BRACE -> ^( SAMETERM expression expression ) | ISIRI OPEN_BRACE expression CLOSE_BRACE -> ^( ISIRI expression ) | ISURI OPEN_BRACE expression CLOSE_BRACE -> ^( ISURI expression ) | ISBLANK OPEN_BRACE expression CLOSE_BRACE -> ^( ISBLANK expression ) | ISLITERAL OPEN_BRACE expression CLOSE_BRACE -> ^( ISLITERAL expression ) | ISNUMERIC OPEN_BRACE expression CLOSE_BRACE -> ^( ISNUMERIC expression ) | regexExpression -> regexExpression | existsFunction -> existsFunction | notExistsFunction -> notExistsFunction );
 18431  
     public final SparqlParser.builtInCall_return builtInCall() throws RecognitionException {
 18432  532
         SparqlParser.builtInCall_return retval = new SparqlParser.builtInCall_return();
 18433  532
         retval.start = input.LT(1);
 18434  
 
 18435  
 
 18436  532
         Object root_0 = null;
 18437  
 
 18438  532
         Token STR388=null;
 18439  532
         Token OPEN_BRACE389=null;
 18440  532
         Token CLOSE_BRACE391=null;
 18441  532
         Token LANG392=null;
 18442  532
         Token OPEN_BRACE393=null;
 18443  532
         Token CLOSE_BRACE395=null;
 18444  532
         Token LANGMATCHES396=null;
 18445  532
         Token OPEN_BRACE397=null;
 18446  532
         Token COMMA399=null;
 18447  532
         Token CLOSE_BRACE401=null;
 18448  532
         Token DATATYPE402=null;
 18449  532
         Token OPEN_BRACE403=null;
 18450  532
         Token CLOSE_BRACE405=null;
 18451  532
         Token BOUND406=null;
 18452  532
         Token OPEN_BRACE407=null;
 18453  532
         Token CLOSE_BRACE409=null;
 18454  532
         Token IRI410=null;
 18455  532
         Token OPEN_BRACE411=null;
 18456  532
         Token CLOSE_BRACE413=null;
 18457  532
         Token URI414=null;
 18458  532
         Token OPEN_BRACE415=null;
 18459  532
         Token CLOSE_BRACE417=null;
 18460  532
         Token BNODE418=null;
 18461  532
         Token OPEN_BRACE419=null;
 18462  532
         Token CLOSE_BRACE421=null;
 18463  532
         Token BNODE422=null;
 18464  532
         Token RAND424=null;
 18465  532
         Token ABS426=null;
 18466  532
         Token OPEN_BRACE427=null;
 18467  532
         Token CLOSE_BRACE429=null;
 18468  532
         Token CEIL430=null;
 18469  532
         Token OPEN_BRACE431=null;
 18470  532
         Token CLOSE_BRACE433=null;
 18471  532
         Token FLOOR434=null;
 18472  532
         Token OPEN_BRACE435=null;
 18473  532
         Token CLOSE_BRACE437=null;
 18474  532
         Token ROUND438=null;
 18475  532
         Token OPEN_BRACE439=null;
 18476  532
         Token CLOSE_BRACE441=null;
 18477  532
         Token CONCAT442=null;
 18478  532
         Token STRLEN445=null;
 18479  532
         Token OPEN_BRACE446=null;
 18480  532
         Token CLOSE_BRACE448=null;
 18481  532
         Token UCASE449=null;
 18482  532
         Token OPEN_BRACE450=null;
 18483  532
         Token CLOSE_BRACE452=null;
 18484  532
         Token LCASE453=null;
 18485  532
         Token OPEN_BRACE454=null;
 18486  532
         Token CLOSE_BRACE456=null;
 18487  532
         Token ENCODE_FOR_URI457=null;
 18488  532
         Token OPEN_BRACE458=null;
 18489  532
         Token CLOSE_BRACE460=null;
 18490  532
         Token CONTAINS461=null;
 18491  532
         Token OPEN_BRACE462=null;
 18492  532
         Token COMMA464=null;
 18493  532
         Token CLOSE_BRACE466=null;
 18494  532
         Token STRSTARTS467=null;
 18495  532
         Token OPEN_BRACE468=null;
 18496  532
         Token COMMA470=null;
 18497  532
         Token CLOSE_BRACE472=null;
 18498  532
         Token STRENDS473=null;
 18499  532
         Token OPEN_BRACE474=null;
 18500  532
         Token COMMA476=null;
 18501  532
         Token CLOSE_BRACE478=null;
 18502  532
         Token STRBEFORE479=null;
 18503  532
         Token OPEN_BRACE480=null;
 18504  532
         Token COMMA482=null;
 18505  532
         Token CLOSE_BRACE484=null;
 18506  532
         Token STRAFTER485=null;
 18507  532
         Token OPEN_BRACE486=null;
 18508  532
         Token COMMA488=null;
 18509  532
         Token CLOSE_BRACE490=null;
 18510  532
         Token REPLACE491=null;
 18511  532
         Token OPEN_BRACE492=null;
 18512  532
         Token COMMA494=null;
 18513  532
         Token COMMA496=null;
 18514  532
         Token CLOSE_BRACE498=null;
 18515  532
         Token YEAR499=null;
 18516  532
         Token OPEN_BRACE500=null;
 18517  532
         Token CLOSE_BRACE502=null;
 18518  532
         Token MONTH503=null;
 18519  532
         Token OPEN_BRACE504=null;
 18520  532
         Token CLOSE_BRACE506=null;
 18521  532
         Token DAY507=null;
 18522  532
         Token OPEN_BRACE508=null;
 18523  532
         Token CLOSE_BRACE510=null;
 18524  532
         Token HOURS511=null;
 18525  532
         Token OPEN_BRACE512=null;
 18526  532
         Token CLOSE_BRACE514=null;
 18527  532
         Token MINUTES515=null;
 18528  532
         Token OPEN_BRACE516=null;
 18529  532
         Token CLOSE_BRACE518=null;
 18530  532
         Token SECONDS519=null;
 18531  532
         Token OPEN_BRACE520=null;
 18532  532
         Token CLOSE_BRACE522=null;
 18533  532
         Token TIMEZONE523=null;
 18534  532
         Token OPEN_BRACE524=null;
 18535  532
         Token CLOSE_BRACE526=null;
 18536  532
         Token TZ527=null;
 18537  532
         Token OPEN_BRACE528=null;
 18538  532
         Token CLOSE_BRACE530=null;
 18539  532
         Token NOW531=null;
 18540  532
         Token MD5533=null;
 18541  532
         Token OPEN_BRACE534=null;
 18542  532
         Token CLOSE_BRACE536=null;
 18543  532
         Token SHA1537=null;
 18544  532
         Token OPEN_BRACE538=null;
 18545  532
         Token CLOSE_BRACE540=null;
 18546  532
         Token SHA224541=null;
 18547  532
         Token OPEN_BRACE542=null;
 18548  532
         Token CLOSE_BRACE544=null;
 18549  532
         Token SHA256545=null;
 18550  532
         Token OPEN_BRACE546=null;
 18551  532
         Token CLOSE_BRACE548=null;
 18552  532
         Token SHA384549=null;
 18553  532
         Token OPEN_BRACE550=null;
 18554  532
         Token CLOSE_BRACE552=null;
 18555  532
         Token SHA512553=null;
 18556  532
         Token OPEN_BRACE554=null;
 18557  532
         Token CLOSE_BRACE556=null;
 18558  532
         Token COALESCE557=null;
 18559  532
         Token IF559=null;
 18560  532
         Token OPEN_BRACE560=null;
 18561  532
         Token COMMA561=null;
 18562  532
         Token COMMA562=null;
 18563  532
         Token CLOSE_BRACE563=null;
 18564  532
         Token STRLANG564=null;
 18565  532
         Token OPEN_BRACE565=null;
 18566  532
         Token COMMA567=null;
 18567  532
         Token CLOSE_BRACE569=null;
 18568  532
         Token STRDT570=null;
 18569  532
         Token OPEN_BRACE571=null;
 18570  532
         Token COMMA573=null;
 18571  532
         Token CLOSE_BRACE575=null;
 18572  532
         Token SAMETERM576=null;
 18573  532
         Token OPEN_BRACE577=null;
 18574  532
         Token COMMA579=null;
 18575  532
         Token CLOSE_BRACE581=null;
 18576  532
         Token ISIRI582=null;
 18577  532
         Token OPEN_BRACE583=null;
 18578  532
         Token CLOSE_BRACE585=null;
 18579  532
         Token ISURI586=null;
 18580  532
         Token OPEN_BRACE587=null;
 18581  532
         Token CLOSE_BRACE589=null;
 18582  532
         Token ISBLANK590=null;
 18583  532
         Token OPEN_BRACE591=null;
 18584  532
         Token CLOSE_BRACE593=null;
 18585  532
         Token ISLITERAL594=null;
 18586  532
         Token OPEN_BRACE595=null;
 18587  532
         Token CLOSE_BRACE597=null;
 18588  532
         Token ISNUMERIC598=null;
 18589  532
         Token OPEN_BRACE599=null;
 18590  532
         Token CLOSE_BRACE601=null;
 18591  532
         SparqlParser.expression_return e1 =null;
 18592  
 
 18593  532
         SparqlParser.expression_return e2 =null;
 18594  
 
 18595  532
         SparqlParser.expression_return e3 =null;
 18596  
 
 18597  532
         SparqlParser.expression_return expression390 =null;
 18598  
 
 18599  532
         SparqlParser.expression_return expression394 =null;
 18600  
 
 18601  532
         SparqlParser.expression_return expression398 =null;
 18602  
 
 18603  532
         SparqlParser.expression_return expression400 =null;
 18604  
 
 18605  532
         SparqlParser.expression_return expression404 =null;
 18606  
 
 18607  532
         SparqlParser.var_return var408 =null;
 18608  
 
 18609  532
         SparqlParser.expression_return expression412 =null;
 18610  
 
 18611  532
         SparqlParser.expression_return expression416 =null;
 18612  
 
 18613  532
         SparqlParser.expression_return expression420 =null;
 18614  
 
 18615  532
         SparqlParser.nil_return nil423 =null;
 18616  
 
 18617  532
         SparqlParser.nil_return nil425 =null;
 18618  
 
 18619  532
         SparqlParser.expression_return expression428 =null;
 18620  
 
 18621  532
         SparqlParser.expression_return expression432 =null;
 18622  
 
 18623  532
         SparqlParser.expression_return expression436 =null;
 18624  
 
 18625  532
         SparqlParser.expression_return expression440 =null;
 18626  
 
 18627  532
         SparqlParser.expressionList_return expressionList443 =null;
 18628  
 
 18629  532
         SparqlParser.subStringExpression_return subStringExpression444 =null;
 18630  
 
 18631  532
         SparqlParser.expression_return expression447 =null;
 18632  
 
 18633  532
         SparqlParser.expression_return expression451 =null;
 18634  
 
 18635  532
         SparqlParser.expression_return expression455 =null;
 18636  
 
 18637  532
         SparqlParser.expression_return expression459 =null;
 18638  
 
 18639  532
         SparqlParser.expression_return expression463 =null;
 18640  
 
 18641  532
         SparqlParser.expression_return expression465 =null;
 18642  
 
 18643  532
         SparqlParser.expression_return expression469 =null;
 18644  
 
 18645  532
         SparqlParser.expression_return expression471 =null;
 18646  
 
 18647  532
         SparqlParser.expression_return expression475 =null;
 18648  
 
 18649  532
         SparqlParser.expression_return expression477 =null;
 18650  
 
 18651  532
         SparqlParser.expression_return expression481 =null;
 18652  
 
 18653  532
         SparqlParser.expression_return expression483 =null;
 18654  
 
 18655  532
         SparqlParser.expression_return expression487 =null;
 18656  
 
 18657  532
         SparqlParser.expression_return expression489 =null;
 18658  
 
 18659  532
         SparqlParser.expression_return expression493 =null;
 18660  
 
 18661  532
         SparqlParser.expression_return expression495 =null;
 18662  
 
 18663  532
         SparqlParser.expression_return expression497 =null;
 18664  
 
 18665  532
         SparqlParser.expression_return expression501 =null;
 18666  
 
 18667  532
         SparqlParser.expression_return expression505 =null;
 18668  
 
 18669  532
         SparqlParser.expression_return expression509 =null;
 18670  
 
 18671  532
         SparqlParser.expression_return expression513 =null;
 18672  
 
 18673  532
         SparqlParser.expression_return expression517 =null;
 18674  
 
 18675  532
         SparqlParser.expression_return expression521 =null;
 18676  
 
 18677  532
         SparqlParser.expression_return expression525 =null;
 18678  
 
 18679  532
         SparqlParser.expression_return expression529 =null;
 18680  
 
 18681  532
         SparqlParser.nil_return nil532 =null;
 18682  
 
 18683  532
         SparqlParser.expression_return expression535 =null;
 18684  
 
 18685  532
         SparqlParser.expression_return expression539 =null;
 18686  
 
 18687  532
         SparqlParser.expression_return expression543 =null;
 18688  
 
 18689  532
         SparqlParser.expression_return expression547 =null;
 18690  
 
 18691  532
         SparqlParser.expression_return expression551 =null;
 18692  
 
 18693  532
         SparqlParser.expression_return expression555 =null;
 18694  
 
 18695  532
         SparqlParser.expressionList_return expressionList558 =null;
 18696  
 
 18697  532
         SparqlParser.expression_return expression566 =null;
 18698  
 
 18699  532
         SparqlParser.expression_return expression568 =null;
 18700  
 
 18701  532
         SparqlParser.expression_return expression572 =null;
 18702  
 
 18703  532
         SparqlParser.expression_return expression574 =null;
 18704  
 
 18705  532
         SparqlParser.expression_return expression578 =null;
 18706  
 
 18707  532
         SparqlParser.expression_return expression580 =null;
 18708  
 
 18709  532
         SparqlParser.expression_return expression584 =null;
 18710  
 
 18711  532
         SparqlParser.expression_return expression588 =null;
 18712  
 
 18713  532
         SparqlParser.expression_return expression592 =null;
 18714  
 
 18715  532
         SparqlParser.expression_return expression596 =null;
 18716  
 
 18717  532
         SparqlParser.expression_return expression600 =null;
 18718  
 
 18719  532
         SparqlParser.regexExpression_return regexExpression602 =null;
 18720  
 
 18721  532
         SparqlParser.existsFunction_return existsFunction603 =null;
 18722  
 
 18723  532
         SparqlParser.notExistsFunction_return notExistsFunction604 =null;
 18724  
 
 18725  
 
 18726  532
         Object STR388_tree=null;
 18727  532
         Object OPEN_BRACE389_tree=null;
 18728  532
         Object CLOSE_BRACE391_tree=null;
 18729  532
         Object LANG392_tree=null;
 18730  532
         Object OPEN_BRACE393_tree=null;
 18731  532
         Object CLOSE_BRACE395_tree=null;
 18732  532
         Object LANGMATCHES396_tree=null;
 18733  532
         Object OPEN_BRACE397_tree=null;
 18734  532
         Object COMMA399_tree=null;
 18735  532
         Object CLOSE_BRACE401_tree=null;
 18736  532
         Object DATATYPE402_tree=null;
 18737  532
         Object OPEN_BRACE403_tree=null;
 18738  532
         Object CLOSE_BRACE405_tree=null;
 18739  532
         Object BOUND406_tree=null;
 18740  532
         Object OPEN_BRACE407_tree=null;
 18741  532
         Object CLOSE_BRACE409_tree=null;
 18742  532
         Object IRI410_tree=null;
 18743  532
         Object OPEN_BRACE411_tree=null;
 18744  532
         Object CLOSE_BRACE413_tree=null;
 18745  532
         Object URI414_tree=null;
 18746  532
         Object OPEN_BRACE415_tree=null;
 18747  532
         Object CLOSE_BRACE417_tree=null;
 18748  532
         Object BNODE418_tree=null;
 18749  532
         Object OPEN_BRACE419_tree=null;
 18750  532
         Object CLOSE_BRACE421_tree=null;
 18751  532
         Object BNODE422_tree=null;
 18752  532
         Object RAND424_tree=null;
 18753  532
         Object ABS426_tree=null;
 18754  532
         Object OPEN_BRACE427_tree=null;
 18755  532
         Object CLOSE_BRACE429_tree=null;
 18756  532
         Object CEIL430_tree=null;
 18757  532
         Object OPEN_BRACE431_tree=null;
 18758  532
         Object CLOSE_BRACE433_tree=null;
 18759  532
         Object FLOOR434_tree=null;
 18760  532
         Object OPEN_BRACE435_tree=null;
 18761  532
         Object CLOSE_BRACE437_tree=null;
 18762  532
         Object ROUND438_tree=null;
 18763  532
         Object OPEN_BRACE439_tree=null;
 18764  532
         Object CLOSE_BRACE441_tree=null;
 18765  532
         Object CONCAT442_tree=null;
 18766  532
         Object STRLEN445_tree=null;
 18767  532
         Object OPEN_BRACE446_tree=null;
 18768  532
         Object CLOSE_BRACE448_tree=null;
 18769  532
         Object UCASE449_tree=null;
 18770  532
         Object OPEN_BRACE450_tree=null;
 18771  532
         Object CLOSE_BRACE452_tree=null;
 18772  532
         Object LCASE453_tree=null;
 18773  532
         Object OPEN_BRACE454_tree=null;
 18774  532
         Object CLOSE_BRACE456_tree=null;
 18775  532
         Object ENCODE_FOR_URI457_tree=null;
 18776  532
         Object OPEN_BRACE458_tree=null;
 18777  532
         Object CLOSE_BRACE460_tree=null;
 18778  532
         Object CONTAINS461_tree=null;
 18779  532
         Object OPEN_BRACE462_tree=null;
 18780  532
         Object COMMA464_tree=null;
 18781  532
         Object CLOSE_BRACE466_tree=null;
 18782  532
         Object STRSTARTS467_tree=null;
 18783  532
         Object OPEN_BRACE468_tree=null;
 18784  532
         Object COMMA470_tree=null;
 18785  532
         Object CLOSE_BRACE472_tree=null;
 18786  532
         Object STRENDS473_tree=null;
 18787  532
         Object OPEN_BRACE474_tree=null;
 18788  532
         Object COMMA476_tree=null;
 18789  532
         Object CLOSE_BRACE478_tree=null;
 18790  532
         Object STRBEFORE479_tree=null;
 18791  532
         Object OPEN_BRACE480_tree=null;
 18792  532
         Object COMMA482_tree=null;
 18793  532
         Object CLOSE_BRACE484_tree=null;
 18794  532
         Object STRAFTER485_tree=null;
 18795  532
         Object OPEN_BRACE486_tree=null;
 18796  532
         Object COMMA488_tree=null;
 18797  532
         Object CLOSE_BRACE490_tree=null;
 18798  532
         Object REPLACE491_tree=null;
 18799  532
         Object OPEN_BRACE492_tree=null;
 18800  532
         Object COMMA494_tree=null;
 18801  532
         Object COMMA496_tree=null;
 18802  532
         Object CLOSE_BRACE498_tree=null;
 18803  532
         Object YEAR499_tree=null;
 18804  532
         Object OPEN_BRACE500_tree=null;
 18805  532
         Object CLOSE_BRACE502_tree=null;
 18806  532
         Object MONTH503_tree=null;
 18807  532
         Object OPEN_BRACE504_tree=null;
 18808  532
         Object CLOSE_BRACE506_tree=null;
 18809  532
         Object DAY507_tree=null;
 18810  532
         Object OPEN_BRACE508_tree=null;
 18811  532
         Object CLOSE_BRACE510_tree=null;
 18812  532
         Object HOURS511_tree=null;
 18813  532
         Object OPEN_BRACE512_tree=null;
 18814  532
         Object CLOSE_BRACE514_tree=null;
 18815  532
         Object MINUTES515_tree=null;
 18816  532
         Object OPEN_BRACE516_tree=null;
 18817  532
         Object CLOSE_BRACE518_tree=null;
 18818  532
         Object SECONDS519_tree=null;
 18819  532
         Object OPEN_BRACE520_tree=null;
 18820  532
         Object CLOSE_BRACE522_tree=null;
 18821  532
         Object TIMEZONE523_tree=null;
 18822  532
         Object OPEN_BRACE524_tree=null;
 18823  532
         Object CLOSE_BRACE526_tree=null;
 18824  532
         Object TZ527_tree=null;
 18825  532
         Object OPEN_BRACE528_tree=null;
 18826  532
         Object CLOSE_BRACE530_tree=null;
 18827  532
         Object NOW531_tree=null;
 18828  532
         Object MD5533_tree=null;
 18829  532
         Object OPEN_BRACE534_tree=null;
 18830  532
         Object CLOSE_BRACE536_tree=null;
 18831  532
         Object SHA1537_tree=null;
 18832  532
         Object OPEN_BRACE538_tree=null;
 18833  532
         Object CLOSE_BRACE540_tree=null;
 18834  532
         Object SHA224541_tree=null;
 18835  532
         Object OPEN_BRACE542_tree=null;
 18836  532
         Object CLOSE_BRACE544_tree=null;
 18837  532
         Object SHA256545_tree=null;
 18838  532
         Object OPEN_BRACE546_tree=null;
 18839  532
         Object CLOSE_BRACE548_tree=null;
 18840  532
         Object SHA384549_tree=null;
 18841  532
         Object OPEN_BRACE550_tree=null;
 18842  532
         Object CLOSE_BRACE552_tree=null;
 18843  532
         Object SHA512553_tree=null;
 18844  532
         Object OPEN_BRACE554_tree=null;
 18845  532
         Object CLOSE_BRACE556_tree=null;
 18846  532
         Object COALESCE557_tree=null;
 18847  532
         Object IF559_tree=null;
 18848  532
         Object OPEN_BRACE560_tree=null;
 18849  532
         Object COMMA561_tree=null;
 18850  532
         Object COMMA562_tree=null;
 18851  532
         Object CLOSE_BRACE563_tree=null;
 18852  532
         Object STRLANG564_tree=null;
 18853  532
         Object OPEN_BRACE565_tree=null;
 18854  532
         Object COMMA567_tree=null;
 18855  532
         Object CLOSE_BRACE569_tree=null;
 18856  532
         Object STRDT570_tree=null;
 18857  532
         Object OPEN_BRACE571_tree=null;
 18858  532
         Object COMMA573_tree=null;
 18859  532
         Object CLOSE_BRACE575_tree=null;
 18860  532
         Object SAMETERM576_tree=null;
 18861  532
         Object OPEN_BRACE577_tree=null;
 18862  532
         Object COMMA579_tree=null;
 18863  532
         Object CLOSE_BRACE581_tree=null;
 18864  532
         Object ISIRI582_tree=null;
 18865  532
         Object OPEN_BRACE583_tree=null;
 18866  532
         Object CLOSE_BRACE585_tree=null;
 18867  532
         Object ISURI586_tree=null;
 18868  532
         Object OPEN_BRACE587_tree=null;
 18869  532
         Object CLOSE_BRACE589_tree=null;
 18870  532
         Object ISBLANK590_tree=null;
 18871  532
         Object OPEN_BRACE591_tree=null;
 18872  532
         Object CLOSE_BRACE593_tree=null;
 18873  532
         Object ISLITERAL594_tree=null;
 18874  532
         Object OPEN_BRACE595_tree=null;
 18875  532
         Object CLOSE_BRACE597_tree=null;
 18876  532
         Object ISNUMERIC598_tree=null;
 18877  532
         Object OPEN_BRACE599_tree=null;
 18878  532
         Object CLOSE_BRACE601_tree=null;
 18879  532
         RewriteRuleTokenStream stream_SHA256=new RewriteRuleTokenStream(adaptor,"token SHA256");
 18880  532
         RewriteRuleTokenStream stream_YEAR=new RewriteRuleTokenStream(adaptor,"token YEAR");
 18881  532
         RewriteRuleTokenStream stream_TIMEZONE=new RewriteRuleTokenStream(adaptor,"token TIMEZONE");
 18882  532
         RewriteRuleTokenStream stream_CONTAINS=new RewriteRuleTokenStream(adaptor,"token CONTAINS");
 18883  532
         RewriteRuleTokenStream stream_STRENDS=new RewriteRuleTokenStream(adaptor,"token STRENDS");
 18884  532
         RewriteRuleTokenStream stream_LCASE=new RewriteRuleTokenStream(adaptor,"token LCASE");
 18885  532
         RewriteRuleTokenStream stream_BNODE=new RewriteRuleTokenStream(adaptor,"token BNODE");
 18886  532
         RewriteRuleTokenStream stream_SHA512=new RewriteRuleTokenStream(adaptor,"token SHA512");
 18887  532
         RewriteRuleTokenStream stream_SECONDS=new RewriteRuleTokenStream(adaptor,"token SECONDS");
 18888  532
         RewriteRuleTokenStream stream_NOW=new RewriteRuleTokenStream(adaptor,"token NOW");
 18889  532
         RewriteRuleTokenStream stream_DAY=new RewriteRuleTokenStream(adaptor,"token DAY");
 18890  532
         RewriteRuleTokenStream stream_SHA224=new RewriteRuleTokenStream(adaptor,"token SHA224");
 18891  532
         RewriteRuleTokenStream stream_STRAFTER=new RewriteRuleTokenStream(adaptor,"token STRAFTER");
 18892  532
         RewriteRuleTokenStream stream_STRLEN=new RewriteRuleTokenStream(adaptor,"token STRLEN");
 18893  532
         RewriteRuleTokenStream stream_MONTH=new RewriteRuleTokenStream(adaptor,"token MONTH");
 18894  532
         RewriteRuleTokenStream stream_ENCODE_FOR_URI=new RewriteRuleTokenStream(adaptor,"token ENCODE_FOR_URI");
 18895  532
         RewriteRuleTokenStream stream_IF=new RewriteRuleTokenStream(adaptor,"token IF");
 18896  532
         RewriteRuleTokenStream stream_ISURI=new RewriteRuleTokenStream(adaptor,"token ISURI");
 18897  532
         RewriteRuleTokenStream stream_STR=new RewriteRuleTokenStream(adaptor,"token STR");
 18898  532
         RewriteRuleTokenStream stream_ISLITERAL=new RewriteRuleTokenStream(adaptor,"token ISLITERAL");
 18899  532
         RewriteRuleTokenStream stream_STRDT=new RewriteRuleTokenStream(adaptor,"token STRDT");
 18900  532
         RewriteRuleTokenStream stream_SAMETERM=new RewriteRuleTokenStream(adaptor,"token SAMETERM");
 18901  532
         RewriteRuleTokenStream stream_MD5=new RewriteRuleTokenStream(adaptor,"token MD5");
 18902  532
         RewriteRuleTokenStream stream_COMMA=new RewriteRuleTokenStream(adaptor,"token COMMA");
 18903  532
         RewriteRuleTokenStream stream_RAND=new RewriteRuleTokenStream(adaptor,"token RAND");
 18904  532
         RewriteRuleTokenStream stream_REPLACE=new RewriteRuleTokenStream(adaptor,"token REPLACE");
 18905  532
         RewriteRuleTokenStream stream_IRI=new RewriteRuleTokenStream(adaptor,"token IRI");
 18906  532
         RewriteRuleTokenStream stream_LANGMATCHES=new RewriteRuleTokenStream(adaptor,"token LANGMATCHES");
 18907  532
         RewriteRuleTokenStream stream_TZ=new RewriteRuleTokenStream(adaptor,"token TZ");
 18908  532
         RewriteRuleTokenStream stream_STRLANG=new RewriteRuleTokenStream(adaptor,"token STRLANG");
 18909  532
         RewriteRuleTokenStream stream_BOUND=new RewriteRuleTokenStream(adaptor,"token BOUND");
 18910  532
         RewriteRuleTokenStream stream_ISIRI=new RewriteRuleTokenStream(adaptor,"token ISIRI");
 18911  532
         RewriteRuleTokenStream stream_COALESCE=new RewriteRuleTokenStream(adaptor,"token COALESCE");
 18912  532
         RewriteRuleTokenStream stream_ISNUMERIC=new RewriteRuleTokenStream(adaptor,"token ISNUMERIC");
 18913  532
         RewriteRuleTokenStream stream_CONCAT=new RewriteRuleTokenStream(adaptor,"token CONCAT");
 18914  532
         RewriteRuleTokenStream stream_STRSTARTS=new RewriteRuleTokenStream(adaptor,"token STRSTARTS");
 18915  532
         RewriteRuleTokenStream stream_STRBEFORE=new RewriteRuleTokenStream(adaptor,"token STRBEFORE");
 18916  532
         RewriteRuleTokenStream stream_CLOSE_BRACE=new RewriteRuleTokenStream(adaptor,"token CLOSE_BRACE");
 18917  532
         RewriteRuleTokenStream stream_SHA1=new RewriteRuleTokenStream(adaptor,"token SHA1");
 18918  532
         RewriteRuleTokenStream stream_FLOOR=new RewriteRuleTokenStream(adaptor,"token FLOOR");
 18919  532
         RewriteRuleTokenStream stream_ISBLANK=new RewriteRuleTokenStream(adaptor,"token ISBLANK");
 18920  532
         RewriteRuleTokenStream stream_UCASE=new RewriteRuleTokenStream(adaptor,"token UCASE");
 18921  532
         RewriteRuleTokenStream stream_URI=new RewriteRuleTokenStream(adaptor,"token URI");
 18922  532
         RewriteRuleTokenStream stream_ABS=new RewriteRuleTokenStream(adaptor,"token ABS");
 18923  532
         RewriteRuleTokenStream stream_MINUTES=new RewriteRuleTokenStream(adaptor,"token MINUTES");
 18924  532
         RewriteRuleTokenStream stream_ROUND=new RewriteRuleTokenStream(adaptor,"token ROUND");
 18925  532
         RewriteRuleTokenStream stream_CEIL=new RewriteRuleTokenStream(adaptor,"token CEIL");
 18926  532
         RewriteRuleTokenStream stream_DATATYPE=new RewriteRuleTokenStream(adaptor,"token DATATYPE");
 18927  532
         RewriteRuleTokenStream stream_OPEN_BRACE=new RewriteRuleTokenStream(adaptor,"token OPEN_BRACE");
 18928  532
         RewriteRuleTokenStream stream_SHA384=new RewriteRuleTokenStream(adaptor,"token SHA384");
 18929  532
         RewriteRuleTokenStream stream_HOURS=new RewriteRuleTokenStream(adaptor,"token HOURS");
 18930  532
         RewriteRuleTokenStream stream_LANG=new RewriteRuleTokenStream(adaptor,"token LANG");
 18931  532
         RewriteRuleSubtreeStream stream_existsFunction=new RewriteRuleSubtreeStream(adaptor,"rule existsFunction");
 18932  532
         RewriteRuleSubtreeStream stream_subStringExpression=new RewriteRuleSubtreeStream(adaptor,"rule subStringExpression");
 18933  532
         RewriteRuleSubtreeStream stream_expression=new RewriteRuleSubtreeStream(adaptor,"rule expression");
 18934  532
         RewriteRuleSubtreeStream stream_notExistsFunction=new RewriteRuleSubtreeStream(adaptor,"rule notExistsFunction");
 18935  532
         RewriteRuleSubtreeStream stream_expressionList=new RewriteRuleSubtreeStream(adaptor,"rule expressionList");
 18936  532
         RewriteRuleSubtreeStream stream_var=new RewriteRuleSubtreeStream(adaptor,"rule var");
 18937  532
         RewriteRuleSubtreeStream stream_regexExpression=new RewriteRuleSubtreeStream(adaptor,"rule regexExpression");
 18938  532
         RewriteRuleSubtreeStream stream_nil=new RewriteRuleSubtreeStream(adaptor,"rule nil");
 18939  
         try {
 18940  
             // com\\googlecode\\sparkleg\\Sparql.g:545:5: ( STR OPEN_BRACE expression CLOSE_BRACE -> ^( STR expression ) | LANG OPEN_BRACE expression CLOSE_BRACE -> ^( LANG expression ) | LANGMATCHES OPEN_BRACE expression COMMA expression CLOSE_BRACE -> ^( LANGMATCHES ( expression )+ ) | DATATYPE OPEN_BRACE expression CLOSE_BRACE -> ^( DATATYPE expression ) | BOUND OPEN_BRACE var CLOSE_BRACE -> ^( BOUND var ) | IRI OPEN_BRACE expression CLOSE_BRACE -> ^( IRI expression ) | URI OPEN_BRACE expression CLOSE_BRACE -> ^( URI expression ) | BNODE ( OPEN_BRACE expression CLOSE_BRACE ) -> ^( BNODE expression ) | BNODE nil -> BNODE | RAND nil -> RAND | ABS OPEN_BRACE expression CLOSE_BRACE -> ^( ABS expression ) | CEIL OPEN_BRACE expression CLOSE_BRACE -> ^( CEIL expression ) | FLOOR OPEN_BRACE expression CLOSE_BRACE -> ^( FLOOR expression ) | ROUND OPEN_BRACE expression CLOSE_BRACE -> ^( ROUND expression ) | CONCAT expressionList -> ^( CONCAT expressionList ) | subStringExpression -> subStringExpression | STRLEN OPEN_BRACE expression CLOSE_BRACE -> ^( STRLEN expression ) | UCASE OPEN_BRACE expression CLOSE_BRACE -> ^( UCASE expression ) | LCASE OPEN_BRACE expression CLOSE_BRACE -> ^( LCASE expression ) | ENCODE_FOR_URI OPEN_BRACE expression CLOSE_BRACE -> ^( ENCODE_FOR_URI expression ) | CONTAINS OPEN_BRACE expression COMMA expression CLOSE_BRACE -> ^( CONTAINS expression expression ) | STRSTARTS OPEN_BRACE expression COMMA expression CLOSE_BRACE -> ^( STRSTARTS expression expression ) | STRENDS OPEN_BRACE expression COMMA expression CLOSE_BRACE -> ^( STRENDS expression expression ) | STRBEFORE OPEN_BRACE expression COMMA expression CLOSE_BRACE -> ^( STRBEFORE expression expression ) | STRAFTER OPEN_BRACE expression COMMA expression CLOSE_BRACE -> ^( STRAFTER expression expression ) | REPLACE OPEN_BRACE expression COMMA expression COMMA expression CLOSE_BRACE -> ^( REPLACE expression expression expression ) | YEAR OPEN_BRACE expression CLOSE_BRACE -> ^( YEAR expression ) | MONTH OPEN_BRACE expression CLOSE_BRACE -> ^( MONTH expression ) | DAY OPEN_BRACE expression CLOSE_BRACE -> ^( DAY expression ) | HOURS OPEN_BRACE expression CLOSE_BRACE -> ^( HOURS expression ) | MINUTES OPEN_BRACE expression CLOSE_BRACE -> ^( MINUTES expression ) | SECONDS OPEN_BRACE expression CLOSE_BRACE -> ^( SECONDS expression ) | TIMEZONE OPEN_BRACE expression CLOSE_BRACE -> ^( TIMEZONE expression ) | TZ OPEN_BRACE expression CLOSE_BRACE -> ^( TZ expression ) | NOW nil -> NOW | MD5 OPEN_BRACE expression CLOSE_BRACE -> ^( MD5 expression ) | SHA1 OPEN_BRACE expression CLOSE_BRACE -> ^( SHA1 expression ) | SHA224 OPEN_BRACE expression CLOSE_BRACE -> ^( SHA224 expression ) | SHA256 OPEN_BRACE expression CLOSE_BRACE -> ^( SHA256 expression ) | SHA384 OPEN_BRACE expression CLOSE_BRACE -> ^( SHA384 expression ) | SHA512 OPEN_BRACE expression CLOSE_BRACE -> ^( SHA512 expression ) | COALESCE expressionList -> ^( COALESCE expressionList ) | IF OPEN_BRACE e1= expression COMMA e2= expression COMMA e3= expression CLOSE_BRACE -> ^( IF $e1 $e2 $e3) | STRLANG OPEN_BRACE expression COMMA expression CLOSE_BRACE -> ^( STRLANG expression expression ) | STRDT OPEN_BRACE expression COMMA expression CLOSE_BRACE -> ^( STRDT expression expression ) | SAMETERM OPEN_BRACE expression COMMA expression CLOSE_BRACE -> ^( SAMETERM expression expression ) | ISIRI OPEN_BRACE expression CLOSE_BRACE -> ^( ISIRI expression ) | ISURI OPEN_BRACE expression CLOSE_BRACE -> ^( ISURI expression ) | ISBLANK OPEN_BRACE expression CLOSE_BRACE -> ^( ISBLANK expression ) | ISLITERAL OPEN_BRACE expression CLOSE_BRACE -> ^( ISLITERAL expression ) | ISNUMERIC OPEN_BRACE expression CLOSE_BRACE -> ^( ISNUMERIC expression ) | regexExpression -> regexExpression | existsFunction -> existsFunction | notExistsFunction -> notExistsFunction )
 18941  532
             int alt126=54;
 18942  532
             switch ( input.LA(1) ) {
 18943  
             case STR:
 18944  
                 {
 18945  36
                 alt126=1;
 18946  
                 }
 18947  36
                 break;
 18948  
             case LANG:
 18949  
                 {
 18950  40
                 alt126=2;
 18951  
                 }
 18952  40
                 break;
 18953  
             case LANGMATCHES:
 18954  
                 {
 18955  30
                 alt126=3;
 18956  
                 }
 18957  30
                 break;
 18958  
             case DATATYPE:
 18959  
                 {
 18960  100
                 alt126=4;
 18961  
                 }
 18962  100
                 break;
 18963  
             case BOUND:
 18964  
                 {
 18965  30
                 alt126=5;
 18966  
                 }
 18967  30
                 break;
 18968  
             case IRI:
 18969  
                 {
 18970  2
                 alt126=6;
 18971  
                 }
 18972  2
                 break;
 18973  
             case URI:
 18974  
                 {
 18975  2
                 alt126=7;
 18976  
                 }
 18977  2
                 break;
 18978  
             case BNODE:
 18979  
                 {
 18980  8
                 switch ( input.LA(2) ) {
 18981  
                 case OPEN_BRACE:
 18982  
                     {
 18983  8
                     switch ( input.LA(3) ) {
 18984  
                     case CLOSE_BRACE:
 18985  
                         {
 18986  4
                         alt126=9;
 18987  
                         }
 18988  4
                         break;
 18989  
                     case ABS:
 18990  
                     case AVG:
 18991  
                     case BNODE:
 18992  
                     case BOUND:
 18993  
                     case CEIL:
 18994  
                     case COALESCE:
 18995  
                     case CONCAT:
 18996  
                     case CONTAINS:
 18997  
                     case COUNT:
 18998  
                     case DATATYPE:
 18999  
                     case DAY:
 19000  
                     case DECIMAL:
 19001  
                     case DECIMAL_NEGATIVE:
 19002  
                     case DECIMAL_POSITIVE:
 19003  
                     case DOUBLE:
 19004  
                     case DOUBLE_NEGATIVE:
 19005  
                     case DOUBLE_POSITIVE:
 19006  
                     case ENCODE_FOR_URI:
 19007  
                     case EXISTS:
 19008  
                     case FALSE:
 19009  
                     case FLOOR:
 19010  
                     case GROUP_CONCAT:
 19011  
                     case HOURS:
 19012  
                     case IF:
 19013  
                     case INTEGER:
 19014  
                     case INTEGER_NEGATIVE:
 19015  
                     case INTEGER_POSITIVE:
 19016  
                     case IRI:
 19017  
                     case IRI_REF:
 19018  
                     case ISBLANK:
 19019  
                     case ISIRI:
 19020  
                     case ISLITERAL:
 19021  
                     case ISNUMERIC:
 19022  
                     case ISURI:
 19023  
                     case LANG:
 19024  
                     case LANGMATCHES:
 19025  
                     case LCASE:
 19026  
                     case MAX:
 19027  
                     case MD5:
 19028  
                     case MIN:
 19029  
                     case MINUS:
 19030  
                     case MINUTES:
 19031  
                     case MONTH:
 19032  
                     case NEGATION:
 19033  
                     case NOT:
 19034  
                     case NOW:
 19035  
                     case OPEN_BRACE:
 19036  
                     case PLUS:
 19037  
                     case PNAME_LN:
 19038  
                     case PNAME_NS:
 19039  
                     case RAND:
 19040  
                     case REGEX:
 19041  
                     case REPLACE:
 19042  
                     case ROUND:
 19043  
                     case SAMETERM:
 19044  
                     case SAMPLE:
 19045  
                     case SECONDS:
 19046  
                     case SHA1:
 19047  
                     case SHA224:
 19048  
                     case SHA256:
 19049  
                     case SHA384:
 19050  
                     case SHA512:
 19051  
                     case STR:
 19052  
                     case STRAFTER:
 19053  
                     case STRBEFORE:
 19054  
                     case STRDT:
 19055  
                     case STRENDS:
 19056  
                     case STRING_LITERAL1:
 19057  
                     case STRING_LITERAL2:
 19058  
                     case STRING_LITERAL_LONG1:
 19059  
                     case STRING_LITERAL_LONG2:
 19060  
                     case STRLANG:
 19061  
                     case STRLEN:
 19062  
                     case STRSTARTS:
 19063  
                     case SUBSTR:
 19064  
                     case SUM:
 19065  
                     case TIMEZONE:
 19066  
                     case TRUE:
 19067  
                     case TZ:
 19068  
                     case UCASE:
 19069  
                     case URI:
 19070  
                     case VAR1:
 19071  
                     case VAR2:
 19072  
                     case YEAR:
 19073  
                         {
 19074  4
                         alt126=8;
 19075  
                         }
 19076  4
                         break;
 19077  
                     default:
 19078  0
                         NoViableAltException nvae =
 19079  
                             new NoViableAltException("", 126, 54, input);
 19080  
 
 19081  0
                         throw nvae;
 19082  
 
 19083  
                     }
 19084  
 
 19085  
                     }
 19086  8
                     break;
 19087  
                 default:
 19088  0
                     NoViableAltException nvae =
 19089  
                         new NoViableAltException("", 126, 8, input);
 19090  
 
 19091  0
                     throw nvae;
 19092  
 
 19093  
                 }
 19094  
 
 19095  
                 }
 19096  8
                 break;
 19097  
             case RAND:
 19098  
                 {
 19099  2
                 alt126=10;
 19100  
                 }
 19101  2
                 break;
 19102  
             case ABS:
 19103  
                 {
 19104  2
                 alt126=11;
 19105  
                 }
 19106  2
                 break;
 19107  
             case CEIL:
 19108  
                 {
 19109  2
                 alt126=12;
 19110  
                 }
 19111  2
                 break;
 19112  
             case FLOOR:
 19113  
                 {
 19114  2
                 alt126=13;
 19115  
                 }
 19116  2
                 break;
 19117  
             case ROUND:
 19118  
                 {
 19119  2
                 alt126=14;
 19120  
                 }
 19121  2
                 break;
 19122  
             case CONCAT:
 19123  
                 {
 19124  10
                 alt126=15;
 19125  
                 }
 19126  10
                 break;
 19127  
             case SUBSTR:
 19128  
                 {
 19129  4
                 alt126=16;
 19130  
                 }
 19131  4
                 break;
 19132  
             case STRLEN:
 19133  
                 {
 19134  2
                 alt126=17;
 19135  
                 }
 19136  2
                 break;
 19137  
             case UCASE:
 19138  
                 {
 19139  2
                 alt126=18;
 19140  
                 }
 19141  2
                 break;
 19142  
             case LCASE:
 19143  
                 {
 19144  2
                 alt126=19;
 19145  
                 }
 19146  2
                 break;
 19147  
             case ENCODE_FOR_URI:
 19148  
                 {
 19149  2
                 alt126=20;
 19150  
                 }
 19151  2
                 break;
 19152  
             case CONTAINS:
 19153  
                 {
 19154  2
                 alt126=21;
 19155  
                 }
 19156  2
                 break;
 19157  
             case STRSTARTS:
 19158  
                 {
 19159  2
                 alt126=22;
 19160  
                 }
 19161  2
                 break;
 19162  
             case STRENDS:
 19163  
                 {
 19164  2
                 alt126=23;
 19165  
                 }
 19166  2
                 break;
 19167  
             case STRBEFORE:
 19168  
                 {
 19169  2
                 alt126=24;
 19170  
                 }
 19171  2
                 break;
 19172  
             case STRAFTER:
 19173  
                 {
 19174  2
                 alt126=25;
 19175  
                 }
 19176  2
                 break;
 19177  
             case REPLACE:
 19178  
                 {
 19179  6
                 alt126=26;
 19180  
                 }
 19181  6
                 break;
 19182  
             case YEAR:
 19183  
                 {
 19184  2
                 alt126=27;
 19185  
                 }
 19186  2
                 break;
 19187  
             case MONTH:
 19188  
                 {
 19189  2
                 alt126=28;
 19190  
                 }
 19191  2
                 break;
 19192  
             case DAY:
 19193  
                 {
 19194  2
                 alt126=29;
 19195  
                 }
 19196  2
                 break;
 19197  
             case HOURS:
 19198  
                 {
 19199  2
                 alt126=30;
 19200  
                 }
 19201  2
                 break;
 19202  
             case MINUTES:
 19203  
                 {
 19204  2
                 alt126=31;
 19205  
                 }
 19206  2
                 break;
 19207  
             case SECONDS:
 19208  
                 {
 19209  2
                 alt126=32;
 19210  
                 }
 19211  2
                 break;
 19212  
             case TIMEZONE:
 19213  
                 {
 19214  2
                 alt126=33;
 19215  
                 }
 19216  2
                 break;
 19217  
             case TZ:
 19218  
                 {
 19219  2
                 alt126=34;
 19220  
                 }
 19221  2
                 break;
 19222  
             case NOW:
 19223  
                 {
 19224  2
                 alt126=35;
 19225  
                 }
 19226  2
                 break;
 19227  
             case MD5:
 19228  
                 {
 19229  4
                 alt126=36;
 19230  
                 }
 19231  4
                 break;
 19232  
             case SHA1:
 19233  
                 {
 19234  4
                 alt126=37;
 19235  
                 }
 19236  4
                 break;
 19237  
             case SHA224:
 19238  
                 {
 19239  0
                 alt126=38;
 19240  
                 }
 19241  0
                 break;
 19242  
             case SHA256:
 19243  
                 {
 19244  4
                 alt126=39;
 19245  
                 }
 19246  4
                 break;
 19247  
             case SHA384:
 19248  
                 {
 19249  4
                 alt126=40;
 19250  
                 }
 19251  4
                 break;
 19252  
             case SHA512:
 19253  
                 {
 19254  4
                 alt126=41;
 19255  
                 }
 19256  4
                 break;
 19257  
             case COALESCE:
 19258  
                 {
 19259  12
                 alt126=42;
 19260  
                 }
 19261  12
                 break;
 19262  
             case IF:
 19263  
                 {
 19264  6
                 alt126=43;
 19265  
                 }
 19266  6
                 break;
 19267  
             case STRLANG:
 19268  
                 {
 19269  6
                 alt126=44;
 19270  
                 }
 19271  6
                 break;
 19272  
             case STRDT:
 19273  
                 {
 19274  6
                 alt126=45;
 19275  
                 }
 19276  6
                 break;
 19277  
             case SAMETERM:
 19278  
                 {
 19279  30
                 alt126=46;
 19280  
                 }
 19281  30
                 break;
 19282  
             case ISIRI:
 19283  
                 {
 19284  8
                 alt126=47;
 19285  
                 }
 19286  8
                 break;
 19287  
             case ISURI:
 19288  
                 {
 19289  2
                 alt126=48;
 19290  
                 }
 19291  2
                 break;
 19292  
             case ISBLANK:
 19293  
                 {
 19294  8
                 alt126=49;
 19295  
                 }
 19296  8
                 break;
 19297  
             case ISLITERAL:
 19298  
                 {
 19299  8
                 alt126=50;
 19300  
                 }
 19301  8
                 break;
 19302  
             case ISNUMERIC:
 19303  
                 {
 19304  4
                 alt126=51;
 19305  
                 }
 19306  4
                 break;
 19307  
             case REGEX:
 19308  
                 {
 19309  42
                 alt126=52;
 19310  
                 }
 19311  42
                 break;
 19312  
             case EXISTS:
 19313  
                 {
 19314  20
                 alt126=53;
 19315  
                 }
 19316  20
                 break;
 19317  
             case NOT:
 19318  
                 {
 19319  46
                 alt126=54;
 19320  
                 }
 19321  46
                 break;
 19322  
             default:
 19323  0
                 NoViableAltException nvae =
 19324  
                     new NoViableAltException("", 126, 0, input);
 19325  
 
 19326  0
                 throw nvae;
 19327  
 
 19328  
             }
 19329  
 
 19330  532
             switch (alt126) {
 19331  
                 case 1 :
 19332  
                     // com\\googlecode\\sparkleg\\Sparql.g:545:7: STR OPEN_BRACE expression CLOSE_BRACE
 19333  
                     {
 19334  36
                     STR388=(Token)match(input,STR,FOLLOW_STR_in_builtInCall5049);  
 19335  36
                     stream_STR.add(STR388);
 19336  
 
 19337  
 
 19338  36
                     OPEN_BRACE389=(Token)match(input,OPEN_BRACE,FOLLOW_OPEN_BRACE_in_builtInCall5051);  
 19339  36
                     stream_OPEN_BRACE.add(OPEN_BRACE389);
 19340  
 
 19341  
 
 19342  36
                     pushFollow(FOLLOW_expression_in_builtInCall5053);
 19343  36
                     expression390=expression();
 19344  
 
 19345  36
                     state._fsp--;
 19346  
 
 19347  36
                     stream_expression.add(expression390.getTree());
 19348  
 
 19349  36
                     CLOSE_BRACE391=(Token)match(input,CLOSE_BRACE,FOLLOW_CLOSE_BRACE_in_builtInCall5055);  
 19350  36
                     stream_CLOSE_BRACE.add(CLOSE_BRACE391);
 19351  
 
 19352  
 
 19353  
                     // AST REWRITE
 19354  
                     // elements: STR, expression
 19355  
                     // token labels: 
 19356  
                     // rule labels: retval
 19357  
                     // token list labels: 
 19358  
                     // rule list labels: 
 19359  
                     // wildcard labels: 
 19360  36
                     retval.tree = root_0;
 19361  36
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 19362  
 
 19363  36
                     root_0 = (Object)adaptor.nil();
 19364  
                     // 545:45: -> ^( STR expression )
 19365  
                     {
 19366  
                         // com\\googlecode\\sparkleg\\Sparql.g:545:48: ^( STR expression )
 19367  
                         {
 19368  36
                         Object root_1 = (Object)adaptor.nil();
 19369  36
                         root_1 = (Object)adaptor.becomeRoot(
 19370  
                         stream_STR.nextNode()
 19371  
                         , root_1);
 19372  
 
 19373  36
                         adaptor.addChild(root_1, stream_expression.nextTree());
 19374  
 
 19375  36
                         adaptor.addChild(root_0, root_1);
 19376  
                         }
 19377  
 
 19378  
                     }
 19379  
 
 19380  
 
 19381  36
                     retval.tree = root_0;
 19382  
 
 19383  
                     }
 19384  36
                     break;
 19385  
                 case 2 :
 19386  
                     // com\\googlecode\\sparkleg\\Sparql.g:546:7: LANG OPEN_BRACE expression CLOSE_BRACE
 19387  
                     {
 19388  40
                     LANG392=(Token)match(input,LANG,FOLLOW_LANG_in_builtInCall5071);  
 19389  40
                     stream_LANG.add(LANG392);
 19390  
 
 19391  
 
 19392  40
                     OPEN_BRACE393=(Token)match(input,OPEN_BRACE,FOLLOW_OPEN_BRACE_in_builtInCall5073);  
 19393  40
                     stream_OPEN_BRACE.add(OPEN_BRACE393);
 19394  
 
 19395  
 
 19396  40
                     pushFollow(FOLLOW_expression_in_builtInCall5075);
 19397  40
                     expression394=expression();
 19398  
 
 19399  40
                     state._fsp--;
 19400  
 
 19401  40
                     stream_expression.add(expression394.getTree());
 19402  
 
 19403  40
                     CLOSE_BRACE395=(Token)match(input,CLOSE_BRACE,FOLLOW_CLOSE_BRACE_in_builtInCall5077);  
 19404  40
                     stream_CLOSE_BRACE.add(CLOSE_BRACE395);
 19405  
 
 19406  
 
 19407  
                     // AST REWRITE
 19408  
                     // elements: expression, LANG
 19409  
                     // token labels: 
 19410  
                     // rule labels: retval
 19411  
                     // token list labels: 
 19412  
                     // rule list labels: 
 19413  
                     // wildcard labels: 
 19414  40
                     retval.tree = root_0;
 19415  40
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 19416  
 
 19417  40
                     root_0 = (Object)adaptor.nil();
 19418  
                     // 546:46: -> ^( LANG expression )
 19419  
                     {
 19420  
                         // com\\googlecode\\sparkleg\\Sparql.g:546:49: ^( LANG expression )
 19421  
                         {
 19422  40
                         Object root_1 = (Object)adaptor.nil();
 19423  40
                         root_1 = (Object)adaptor.becomeRoot(
 19424  
                         stream_LANG.nextNode()
 19425  
                         , root_1);
 19426  
 
 19427  40
                         adaptor.addChild(root_1, stream_expression.nextTree());
 19428  
 
 19429  40
                         adaptor.addChild(root_0, root_1);
 19430  
                         }
 19431  
 
 19432  
                     }
 19433  
 
 19434  
 
 19435  40
                     retval.tree = root_0;
 19436  
 
 19437  
                     }
 19438  40
                     break;
 19439  
                 case 3 :
 19440  
                     // com\\googlecode\\sparkleg\\Sparql.g:547:7: LANGMATCHES OPEN_BRACE expression COMMA expression CLOSE_BRACE
 19441  
                     {
 19442  30
                     LANGMATCHES396=(Token)match(input,LANGMATCHES,FOLLOW_LANGMATCHES_in_builtInCall5093);  
 19443  30
                     stream_LANGMATCHES.add(LANGMATCHES396);
 19444  
 
 19445  
 
 19446  30
                     OPEN_BRACE397=(Token)match(input,OPEN_BRACE,FOLLOW_OPEN_BRACE_in_builtInCall5095);  
 19447  30
                     stream_OPEN_BRACE.add(OPEN_BRACE397);
 19448  
 
 19449  
 
 19450  30
                     pushFollow(FOLLOW_expression_in_builtInCall5097);
 19451  30
                     expression398=expression();
 19452  
 
 19453  30
                     state._fsp--;
 19454  
 
 19455  30
                     stream_expression.add(expression398.getTree());
 19456  
 
 19457  30
                     COMMA399=(Token)match(input,COMMA,FOLLOW_COMMA_in_builtInCall5099);  
 19458  30
                     stream_COMMA.add(COMMA399);
 19459  
 
 19460  
 
 19461  30
                     pushFollow(FOLLOW_expression_in_builtInCall5101);
 19462  30
                     expression400=expression();
 19463  
 
 19464  30
                     state._fsp--;
 19465  
 
 19466  30
                     stream_expression.add(expression400.getTree());
 19467  
 
 19468  30
                     CLOSE_BRACE401=(Token)match(input,CLOSE_BRACE,FOLLOW_CLOSE_BRACE_in_builtInCall5103);  
 19469  30
                     stream_CLOSE_BRACE.add(CLOSE_BRACE401);
 19470  
 
 19471  
 
 19472  
                     // AST REWRITE
 19473  
                     // elements: expression, LANGMATCHES
 19474  
                     // token labels: 
 19475  
                     // rule labels: retval
 19476  
                     // token list labels: 
 19477  
                     // rule list labels: 
 19478  
                     // wildcard labels: 
 19479  30
                     retval.tree = root_0;
 19480  30
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 19481  
 
 19482  30
                     root_0 = (Object)adaptor.nil();
 19483  
                     // 547:70: -> ^( LANGMATCHES ( expression )+ )
 19484  
                     {
 19485  
                         // com\\googlecode\\sparkleg\\Sparql.g:547:73: ^( LANGMATCHES ( expression )+ )
 19486  
                         {
 19487  30
                         Object root_1 = (Object)adaptor.nil();
 19488  30
                         root_1 = (Object)adaptor.becomeRoot(
 19489  
                         stream_LANGMATCHES.nextNode()
 19490  
                         , root_1);
 19491  
 
 19492  30
                         if ( !(stream_expression.hasNext()) ) {
 19493  0
                             throw new RewriteEarlyExitException();
 19494  
                         }
 19495  90
                         while ( stream_expression.hasNext() ) {
 19496  60
                             adaptor.addChild(root_1, stream_expression.nextTree());
 19497  
 
 19498  
                         }
 19499  30
                         stream_expression.reset();
 19500  
 
 19501  30
                         adaptor.addChild(root_0, root_1);
 19502  
                         }
 19503  
 
 19504  
                     }
 19505  
 
 19506  
 
 19507  30
                     retval.tree = root_0;
 19508  
 
 19509  
                     }
 19510  30
                     break;
 19511  
                 case 4 :
 19512  
                     // com\\googlecode\\sparkleg\\Sparql.g:548:7: DATATYPE OPEN_BRACE expression CLOSE_BRACE
 19513  
                     {
 19514  100
                     DATATYPE402=(Token)match(input,DATATYPE,FOLLOW_DATATYPE_in_builtInCall5120);  
 19515  100
                     stream_DATATYPE.add(DATATYPE402);
 19516  
 
 19517  
 
 19518  100
                     OPEN_BRACE403=(Token)match(input,OPEN_BRACE,FOLLOW_OPEN_BRACE_in_builtInCall5122);  
 19519  100
                     stream_OPEN_BRACE.add(OPEN_BRACE403);
 19520  
 
 19521  
 
 19522  100
                     pushFollow(FOLLOW_expression_in_builtInCall5124);
 19523  100
                     expression404=expression();
 19524  
 
 19525  100
                     state._fsp--;
 19526  
 
 19527  100
                     stream_expression.add(expression404.getTree());
 19528  
 
 19529  100
                     CLOSE_BRACE405=(Token)match(input,CLOSE_BRACE,FOLLOW_CLOSE_BRACE_in_builtInCall5126);  
 19530  100
                     stream_CLOSE_BRACE.add(CLOSE_BRACE405);
 19531  
 
 19532  
 
 19533  
                     // AST REWRITE
 19534  
                     // elements: expression, DATATYPE
 19535  
                     // token labels: 
 19536  
                     // rule labels: retval
 19537  
                     // token list labels: 
 19538  
                     // rule list labels: 
 19539  
                     // wildcard labels: 
 19540  100
                     retval.tree = root_0;
 19541  100
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 19542  
 
 19543  100
                     root_0 = (Object)adaptor.nil();
 19544  
                     // 548:50: -> ^( DATATYPE expression )
 19545  
                     {
 19546  
                         // com\\googlecode\\sparkleg\\Sparql.g:548:53: ^( DATATYPE expression )
 19547  
                         {
 19548  100
                         Object root_1 = (Object)adaptor.nil();
 19549  100
                         root_1 = (Object)adaptor.becomeRoot(
 19550  
                         stream_DATATYPE.nextNode()
 19551  
                         , root_1);
 19552  
 
 19553  100
                         adaptor.addChild(root_1, stream_expression.nextTree());
 19554  
 
 19555  100
                         adaptor.addChild(root_0, root_1);
 19556  
                         }
 19557  
 
 19558  
                     }
 19559  
 
 19560  
 
 19561  100
                     retval.tree = root_0;
 19562  
 
 19563  
                     }
 19564  100
                     break;
 19565  
                 case 5 :
 19566  
                     // com\\googlecode\\sparkleg\\Sparql.g:549:7: BOUND OPEN_BRACE var CLOSE_BRACE
 19567  
                     {
 19568  30
                     BOUND406=(Token)match(input,BOUND,FOLLOW_BOUND_in_builtInCall5142);  
 19569  30
                     stream_BOUND.add(BOUND406);
 19570  
 
 19571  
 
 19572  30
                     OPEN_BRACE407=(Token)match(input,OPEN_BRACE,FOLLOW_OPEN_BRACE_in_builtInCall5144);  
 19573  30
                     stream_OPEN_BRACE.add(OPEN_BRACE407);
 19574  
 
 19575  
 
 19576  30
                     pushFollow(FOLLOW_var_in_builtInCall5146);
 19577  30
                     var408=var();
 19578  
 
 19579  30
                     state._fsp--;
 19580  
 
 19581  30
                     stream_var.add(var408.getTree());
 19582  
 
 19583  30
                     CLOSE_BRACE409=(Token)match(input,CLOSE_BRACE,FOLLOW_CLOSE_BRACE_in_builtInCall5148);  
 19584  30
                     stream_CLOSE_BRACE.add(CLOSE_BRACE409);
 19585  
 
 19586  
 
 19587  
                     // AST REWRITE
 19588  
                     // elements: var, BOUND
 19589  
                     // token labels: 
 19590  
                     // rule labels: retval
 19591  
                     // token list labels: 
 19592  
                     // rule list labels: 
 19593  
                     // wildcard labels: 
 19594  30
                     retval.tree = root_0;
 19595  30
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 19596  
 
 19597  30
                     root_0 = (Object)adaptor.nil();
 19598  
                     // 549:40: -> ^( BOUND var )
 19599  
                     {
 19600  
                         // com\\googlecode\\sparkleg\\Sparql.g:549:43: ^( BOUND var )
 19601  
                         {
 19602  30
                         Object root_1 = (Object)adaptor.nil();
 19603  30
                         root_1 = (Object)adaptor.becomeRoot(
 19604  
                         stream_BOUND.nextNode()
 19605  
                         , root_1);
 19606  
 
 19607  30
                         adaptor.addChild(root_1, stream_var.nextTree());
 19608  
 
 19609  30
                         adaptor.addChild(root_0, root_1);
 19610  
                         }
 19611  
 
 19612  
                     }
 19613  
 
 19614  
 
 19615  30
                     retval.tree = root_0;
 19616  
 
 19617  
                     }
 19618  30
                     break;
 19619  
                 case 6 :
 19620  
                     // com\\googlecode\\sparkleg\\Sparql.g:550:7: IRI OPEN_BRACE expression CLOSE_BRACE
 19621  
                     {
 19622  2
                     IRI410=(Token)match(input,IRI,FOLLOW_IRI_in_builtInCall5164);  
 19623  2
                     stream_IRI.add(IRI410);
 19624  
 
 19625  
 
 19626  2
                     OPEN_BRACE411=(Token)match(input,OPEN_BRACE,FOLLOW_OPEN_BRACE_in_builtInCall5166);  
 19627  2
                     stream_OPEN_BRACE.add(OPEN_BRACE411);
 19628  
 
 19629  
 
 19630  2
                     pushFollow(FOLLOW_expression_in_builtInCall5168);
 19631  2
                     expression412=expression();
 19632  
 
 19633  2
                     state._fsp--;
 19634  
 
 19635  2
                     stream_expression.add(expression412.getTree());
 19636  
 
 19637  2
                     CLOSE_BRACE413=(Token)match(input,CLOSE_BRACE,FOLLOW_CLOSE_BRACE_in_builtInCall5170);  
 19638  2
                     stream_CLOSE_BRACE.add(CLOSE_BRACE413);
 19639  
 
 19640  
 
 19641  
                     // AST REWRITE
 19642  
                     // elements: expression, IRI
 19643  
                     // token labels: 
 19644  
                     // rule labels: retval
 19645  
                     // token list labels: 
 19646  
                     // rule list labels: 
 19647  
                     // wildcard labels: 
 19648  2
                     retval.tree = root_0;
 19649  2
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 19650  
 
 19651  2
                     root_0 = (Object)adaptor.nil();
 19652  
                     // 550:45: -> ^( IRI expression )
 19653  
                     {
 19654  
                         // com\\googlecode\\sparkleg\\Sparql.g:550:48: ^( IRI expression )
 19655  
                         {
 19656  2
                         Object root_1 = (Object)adaptor.nil();
 19657  2
                         root_1 = (Object)adaptor.becomeRoot(
 19658  
                         stream_IRI.nextNode()
 19659  
                         , root_1);
 19660  
 
 19661  2
                         adaptor.addChild(root_1, stream_expression.nextTree());
 19662  
 
 19663  2
                         adaptor.addChild(root_0, root_1);
 19664  
                         }
 19665  
 
 19666  
                     }
 19667  
 
 19668  
 
 19669  2
                     retval.tree = root_0;
 19670  
 
 19671  
                     }
 19672  2
                     break;
 19673  
                 case 7 :
 19674  
                     // com\\googlecode\\sparkleg\\Sparql.g:551:7: URI OPEN_BRACE expression CLOSE_BRACE
 19675  
                     {
 19676  2
                     URI414=(Token)match(input,URI,FOLLOW_URI_in_builtInCall5186);  
 19677  2
                     stream_URI.add(URI414);
 19678  
 
 19679  
 
 19680  2
                     OPEN_BRACE415=(Token)match(input,OPEN_BRACE,FOLLOW_OPEN_BRACE_in_builtInCall5188);  
 19681  2
                     stream_OPEN_BRACE.add(OPEN_BRACE415);
 19682  
 
 19683  
 
 19684  2
                     pushFollow(FOLLOW_expression_in_builtInCall5190);
 19685  2
                     expression416=expression();
 19686  
 
 19687  2
                     state._fsp--;
 19688  
 
 19689  2
                     stream_expression.add(expression416.getTree());
 19690  
 
 19691  2
                     CLOSE_BRACE417=(Token)match(input,CLOSE_BRACE,FOLLOW_CLOSE_BRACE_in_builtInCall5192);  
 19692  2
                     stream_CLOSE_BRACE.add(CLOSE_BRACE417);
 19693  
 
 19694  
 
 19695  
                     // AST REWRITE
 19696  
                     // elements: expression, URI
 19697  
                     // token labels: 
 19698  
                     // rule labels: retval
 19699  
                     // token list labels: 
 19700  
                     // rule list labels: 
 19701  
                     // wildcard labels: 
 19702  2
                     retval.tree = root_0;
 19703  2
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 19704  
 
 19705  2
                     root_0 = (Object)adaptor.nil();
 19706  
                     // 551:45: -> ^( URI expression )
 19707  
                     {
 19708  
                         // com\\googlecode\\sparkleg\\Sparql.g:551:48: ^( URI expression )
 19709  
                         {
 19710  2
                         Object root_1 = (Object)adaptor.nil();
 19711  2
                         root_1 = (Object)adaptor.becomeRoot(
 19712  
                         stream_URI.nextNode()
 19713  
                         , root_1);
 19714  
 
 19715  2
                         adaptor.addChild(root_1, stream_expression.nextTree());
 19716  
 
 19717  2
                         adaptor.addChild(root_0, root_1);
 19718  
                         }
 19719  
 
 19720  
                     }
 19721  
 
 19722  
 
 19723  2
                     retval.tree = root_0;
 19724  
 
 19725  
                     }
 19726  2
                     break;
 19727  
                 case 8 :
 19728  
                     // com\\googlecode\\sparkleg\\Sparql.g:552:7: BNODE ( OPEN_BRACE expression CLOSE_BRACE )
 19729  
                     {
 19730  4
                     BNODE418=(Token)match(input,BNODE,FOLLOW_BNODE_in_builtInCall5208);  
 19731  4
                     stream_BNODE.add(BNODE418);
 19732  
 
 19733  
 
 19734  
                     // com\\googlecode\\sparkleg\\Sparql.g:552:13: ( OPEN_BRACE expression CLOSE_BRACE )
 19735  
                     // com\\googlecode\\sparkleg\\Sparql.g:552:14: OPEN_BRACE expression CLOSE_BRACE
 19736  
                     {
 19737  4
                     OPEN_BRACE419=(Token)match(input,OPEN_BRACE,FOLLOW_OPEN_BRACE_in_builtInCall5211);  
 19738  4
                     stream_OPEN_BRACE.add(OPEN_BRACE419);
 19739  
 
 19740  
 
 19741  4
                     pushFollow(FOLLOW_expression_in_builtInCall5213);
 19742  4
                     expression420=expression();
 19743  
 
 19744  4
                     state._fsp--;
 19745  
 
 19746  4
                     stream_expression.add(expression420.getTree());
 19747  
 
 19748  4
                     CLOSE_BRACE421=(Token)match(input,CLOSE_BRACE,FOLLOW_CLOSE_BRACE_in_builtInCall5215);  
 19749  4
                     stream_CLOSE_BRACE.add(CLOSE_BRACE421);
 19750  
 
 19751  
 
 19752  
                     }
 19753  
 
 19754  
 
 19755  
                     // AST REWRITE
 19756  
                     // elements: expression, BNODE
 19757  
                     // token labels: 
 19758  
                     // rule labels: retval
 19759  
                     // token list labels: 
 19760  
                     // rule list labels: 
 19761  
                     // wildcard labels: 
 19762  4
                     retval.tree = root_0;
 19763  4
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 19764  
 
 19765  4
                     root_0 = (Object)adaptor.nil();
 19766  
                     // 552:49: -> ^( BNODE expression )
 19767  
                     {
 19768  
                         // com\\googlecode\\sparkleg\\Sparql.g:552:52: ^( BNODE expression )
 19769  
                         {
 19770  4
                         Object root_1 = (Object)adaptor.nil();
 19771  4
                         root_1 = (Object)adaptor.becomeRoot(
 19772  
                         stream_BNODE.nextNode()
 19773  
                         , root_1);
 19774  
 
 19775  4
                         adaptor.addChild(root_1, stream_expression.nextTree());
 19776  
 
 19777  4
                         adaptor.addChild(root_0, root_1);
 19778  
                         }
 19779  
 
 19780  
                     }
 19781  
 
 19782  
 
 19783  4
                     retval.tree = root_0;
 19784  
 
 19785  
                     }
 19786  4
                     break;
 19787  
                 case 9 :
 19788  
                     // com\\googlecode\\sparkleg\\Sparql.g:553:7: BNODE nil
 19789  
                     {
 19790  4
                     BNODE422=(Token)match(input,BNODE,FOLLOW_BNODE_in_builtInCall5232);  
 19791  4
                     stream_BNODE.add(BNODE422);
 19792  
 
 19793  
 
 19794  4
                     pushFollow(FOLLOW_nil_in_builtInCall5234);
 19795  4
                     nil423=nil();
 19796  
 
 19797  4
                     state._fsp--;
 19798  
 
 19799  4
                     stream_nil.add(nil423.getTree());
 19800  
 
 19801  
                     // AST REWRITE
 19802  
                     // elements: BNODE
 19803  
                     // token labels: 
 19804  
                     // rule labels: retval
 19805  
                     // token list labels: 
 19806  
                     // rule list labels: 
 19807  
                     // wildcard labels: 
 19808  4
                     retval.tree = root_0;
 19809  4
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 19810  
 
 19811  4
                     root_0 = (Object)adaptor.nil();
 19812  
                     // 553:17: -> BNODE
 19813  
                     {
 19814  4
                         adaptor.addChild(root_0, 
 19815  
                         stream_BNODE.nextNode()
 19816  
                         );
 19817  
 
 19818  
                     }
 19819  
 
 19820  
 
 19821  4
                     retval.tree = root_0;
 19822  
 
 19823  
                     }
 19824  4
                     break;
 19825  
                 case 10 :
 19826  
                     // com\\googlecode\\sparkleg\\Sparql.g:554:7: RAND nil
 19827  
                     {
 19828  2
                     RAND424=(Token)match(input,RAND,FOLLOW_RAND_in_builtInCall5246);  
 19829  2
                     stream_RAND.add(RAND424);
 19830  
 
 19831  
 
 19832  2
                     pushFollow(FOLLOW_nil_in_builtInCall5248);
 19833  2
                     nil425=nil();
 19834  
 
 19835  2
                     state._fsp--;
 19836  
 
 19837  2
                     stream_nil.add(nil425.getTree());
 19838  
 
 19839  
                     // AST REWRITE
 19840  
                     // elements: RAND
 19841  
                     // token labels: 
 19842  
                     // rule labels: retval
 19843  
                     // token list labels: 
 19844  
                     // rule list labels: 
 19845  
                     // wildcard labels: 
 19846  2
                     retval.tree = root_0;
 19847  2
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 19848  
 
 19849  2
                     root_0 = (Object)adaptor.nil();
 19850  
                     // 554:16: -> RAND
 19851  
                     {
 19852  2
                         adaptor.addChild(root_0, 
 19853  
                         stream_RAND.nextNode()
 19854  
                         );
 19855  
 
 19856  
                     }
 19857  
 
 19858  
 
 19859  2
                     retval.tree = root_0;
 19860  
 
 19861  
                     }
 19862  2
                     break;
 19863  
                 case 11 :
 19864  
                     // com\\googlecode\\sparkleg\\Sparql.g:555:7: ABS OPEN_BRACE expression CLOSE_BRACE
 19865  
                     {
 19866  2
                     ABS426=(Token)match(input,ABS,FOLLOW_ABS_in_builtInCall5260);  
 19867  2
                     stream_ABS.add(ABS426);
 19868  
 
 19869  
 
 19870  2
                     OPEN_BRACE427=(Token)match(input,OPEN_BRACE,FOLLOW_OPEN_BRACE_in_builtInCall5262);  
 19871  2
                     stream_OPEN_BRACE.add(OPEN_BRACE427);
 19872  
 
 19873  
 
 19874  2
                     pushFollow(FOLLOW_expression_in_builtInCall5264);
 19875  2
                     expression428=expression();
 19876  
 
 19877  2
                     state._fsp--;
 19878  
 
 19879  2
                     stream_expression.add(expression428.getTree());
 19880  
 
 19881  2
                     CLOSE_BRACE429=(Token)match(input,CLOSE_BRACE,FOLLOW_CLOSE_BRACE_in_builtInCall5266);  
 19882  2
                     stream_CLOSE_BRACE.add(CLOSE_BRACE429);
 19883  
 
 19884  
 
 19885  
                     // AST REWRITE
 19886  
                     // elements: expression, ABS
 19887  
                     // token labels: 
 19888  
                     // rule labels: retval
 19889  
                     // token list labels: 
 19890  
                     // rule list labels: 
 19891  
                     // wildcard labels: 
 19892  2
                     retval.tree = root_0;
 19893  2
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 19894  
 
 19895  2
                     root_0 = (Object)adaptor.nil();
 19896  
                     // 555:45: -> ^( ABS expression )
 19897  
                     {
 19898  
                         // com\\googlecode\\sparkleg\\Sparql.g:555:48: ^( ABS expression )
 19899  
                         {
 19900  2
                         Object root_1 = (Object)adaptor.nil();
 19901  2
                         root_1 = (Object)adaptor.becomeRoot(
 19902  
                         stream_ABS.nextNode()
 19903  
                         , root_1);
 19904  
 
 19905  2
                         adaptor.addChild(root_1, stream_expression.nextTree());
 19906  
 
 19907  2
                         adaptor.addChild(root_0, root_1);
 19908  
                         }
 19909  
 
 19910  
                     }
 19911  
 
 19912  
 
 19913  2
                     retval.tree = root_0;
 19914  
 
 19915  
                     }
 19916  2
                     break;
 19917  
                 case 12 :
 19918  
                     // com\\googlecode\\sparkleg\\Sparql.g:556:7: CEIL OPEN_BRACE expression CLOSE_BRACE
 19919  
                     {
 19920  2
                     CEIL430=(Token)match(input,CEIL,FOLLOW_CEIL_in_builtInCall5282);  
 19921  2
                     stream_CEIL.add(CEIL430);
 19922  
 
 19923  
 
 19924  2
                     OPEN_BRACE431=(Token)match(input,OPEN_BRACE,FOLLOW_OPEN_BRACE_in_builtInCall5284);  
 19925  2
                     stream_OPEN_BRACE.add(OPEN_BRACE431);
 19926  
 
 19927  
 
 19928  2
                     pushFollow(FOLLOW_expression_in_builtInCall5286);
 19929  2
                     expression432=expression();
 19930  
 
 19931  2
                     state._fsp--;
 19932  
 
 19933  2
                     stream_expression.add(expression432.getTree());
 19934  
 
 19935  2
                     CLOSE_BRACE433=(Token)match(input,CLOSE_BRACE,FOLLOW_CLOSE_BRACE_in_builtInCall5288);  
 19936  2
                     stream_CLOSE_BRACE.add(CLOSE_BRACE433);
 19937  
 
 19938  
 
 19939  
                     // AST REWRITE
 19940  
                     // elements: expression, CEIL
 19941  
                     // token labels: 
 19942  
                     // rule labels: retval
 19943  
                     // token list labels: 
 19944  
                     // rule list labels: 
 19945  
                     // wildcard labels: 
 19946  2
                     retval.tree = root_0;
 19947  2
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 19948  
 
 19949  2
                     root_0 = (Object)adaptor.nil();
 19950  
                     // 556:46: -> ^( CEIL expression )
 19951  
                     {
 19952  
                         // com\\googlecode\\sparkleg\\Sparql.g:556:49: ^( CEIL expression )
 19953  
                         {
 19954  2
                         Object root_1 = (Object)adaptor.nil();
 19955  2
                         root_1 = (Object)adaptor.becomeRoot(
 19956  
                         stream_CEIL.nextNode()
 19957  
                         , root_1);
 19958  
 
 19959  2
                         adaptor.addChild(root_1, stream_expression.nextTree());
 19960  
 
 19961  2
                         adaptor.addChild(root_0, root_1);
 19962  
                         }
 19963  
 
 19964  
                     }
 19965  
 
 19966  
 
 19967  2
                     retval.tree = root_0;
 19968  
 
 19969  
                     }
 19970  2
                     break;
 19971  
                 case 13 :
 19972  
                     // com\\googlecode\\sparkleg\\Sparql.g:557:7: FLOOR OPEN_BRACE expression CLOSE_BRACE
 19973  
                     {
 19974  2
                     FLOOR434=(Token)match(input,FLOOR,FOLLOW_FLOOR_in_builtInCall5304);  
 19975  2
                     stream_FLOOR.add(FLOOR434);
 19976  
 
 19977  
 
 19978  2
                     OPEN_BRACE435=(Token)match(input,OPEN_BRACE,FOLLOW_OPEN_BRACE_in_builtInCall5306);  
 19979  2
                     stream_OPEN_BRACE.add(OPEN_BRACE435);
 19980  
 
 19981  
 
 19982  2
                     pushFollow(FOLLOW_expression_in_builtInCall5308);
 19983  2
                     expression436=expression();
 19984  
 
 19985  2
                     state._fsp--;
 19986  
 
 19987  2
                     stream_expression.add(expression436.getTree());
 19988  
 
 19989  2
                     CLOSE_BRACE437=(Token)match(input,CLOSE_BRACE,FOLLOW_CLOSE_BRACE_in_builtInCall5310);  
 19990  2
                     stream_CLOSE_BRACE.add(CLOSE_BRACE437);
 19991  
 
 19992  
 
 19993  
                     // AST REWRITE
 19994  
                     // elements: expression, FLOOR
 19995  
                     // token labels: 
 19996  
                     // rule labels: retval
 19997  
                     // token list labels: 
 19998  
                     // rule list labels: 
 19999  
                     // wildcard labels: 
 20000  2
                     retval.tree = root_0;
 20001  2
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 20002  
 
 20003  2
                     root_0 = (Object)adaptor.nil();
 20004  
                     // 557:47: -> ^( FLOOR expression )
 20005  
                     {
 20006  
                         // com\\googlecode\\sparkleg\\Sparql.g:557:50: ^( FLOOR expression )
 20007  
                         {
 20008  2
                         Object root_1 = (Object)adaptor.nil();
 20009  2
                         root_1 = (Object)adaptor.becomeRoot(
 20010  
                         stream_FLOOR.nextNode()
 20011  
                         , root_1);
 20012  
 
 20013  2
                         adaptor.addChild(root_1, stream_expression.nextTree());
 20014  
 
 20015  2
                         adaptor.addChild(root_0, root_1);
 20016  
                         }
 20017  
 
 20018  
                     }
 20019  
 
 20020  
 
 20021  2
                     retval.tree = root_0;
 20022  
 
 20023  
                     }
 20024  2
                     break;
 20025  
                 case 14 :
 20026  
                     // com\\googlecode\\sparkleg\\Sparql.g:558:7: ROUND OPEN_BRACE expression CLOSE_BRACE
 20027  
                     {
 20028  2
                     ROUND438=(Token)match(input,ROUND,FOLLOW_ROUND_in_builtInCall5326);  
 20029  2
                     stream_ROUND.add(ROUND438);
 20030  
 
 20031  
 
 20032  2
                     OPEN_BRACE439=(Token)match(input,OPEN_BRACE,FOLLOW_OPEN_BRACE_in_builtInCall5328);  
 20033  2
                     stream_OPEN_BRACE.add(OPEN_BRACE439);
 20034  
 
 20035  
 
 20036  2
                     pushFollow(FOLLOW_expression_in_builtInCall5330);
 20037  2
                     expression440=expression();
 20038  
 
 20039  2
                     state._fsp--;
 20040  
 
 20041  2
                     stream_expression.add(expression440.getTree());
 20042  
 
 20043  2
                     CLOSE_BRACE441=(Token)match(input,CLOSE_BRACE,FOLLOW_CLOSE_BRACE_in_builtInCall5332);  
 20044  2
                     stream_CLOSE_BRACE.add(CLOSE_BRACE441);
 20045  
 
 20046  
 
 20047  
                     // AST REWRITE
 20048  
                     // elements: ROUND, expression
 20049  
                     // token labels: 
 20050  
                     // rule labels: retval
 20051  
                     // token list labels: 
 20052  
                     // rule list labels: 
 20053  
                     // wildcard labels: 
 20054  2
                     retval.tree = root_0;
 20055  2
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 20056  
 
 20057  2
                     root_0 = (Object)adaptor.nil();
 20058  
                     // 558:47: -> ^( ROUND expression )
 20059  
                     {
 20060  
                         // com\\googlecode\\sparkleg\\Sparql.g:558:50: ^( ROUND expression )
 20061  
                         {
 20062  2
                         Object root_1 = (Object)adaptor.nil();
 20063  2
                         root_1 = (Object)adaptor.becomeRoot(
 20064  
                         stream_ROUND.nextNode()
 20065  
                         , root_1);
 20066  
 
 20067  2
                         adaptor.addChild(root_1, stream_expression.nextTree());
 20068  
 
 20069  2
                         adaptor.addChild(root_0, root_1);
 20070  
                         }
 20071  
 
 20072  
                     }
 20073  
 
 20074  
 
 20075  2
                     retval.tree = root_0;
 20076  
 
 20077  
                     }
 20078  2
                     break;
 20079  
                 case 15 :
 20080  
                     // com\\googlecode\\sparkleg\\Sparql.g:559:7: CONCAT expressionList
 20081  
                     {
 20082  10
                     CONCAT442=(Token)match(input,CONCAT,FOLLOW_CONCAT_in_builtInCall5348);  
 20083  10
                     stream_CONCAT.add(CONCAT442);
 20084  
 
 20085  
 
 20086  10
                     pushFollow(FOLLOW_expressionList_in_builtInCall5350);
 20087  10
                     expressionList443=expressionList();
 20088  
 
 20089  10
                     state._fsp--;
 20090  
 
 20091  10
                     stream_expressionList.add(expressionList443.getTree());
 20092  
 
 20093  
                     // AST REWRITE
 20094  
                     // elements: expressionList, CONCAT
 20095  
                     // token labels: 
 20096  
                     // rule labels: retval
 20097  
                     // token list labels: 
 20098  
                     // rule list labels: 
 20099  
                     // wildcard labels: 
 20100  10
                     retval.tree = root_0;
 20101  10
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 20102  
 
 20103  10
                     root_0 = (Object)adaptor.nil();
 20104  
                     // 559:29: -> ^( CONCAT expressionList )
 20105  
                     {
 20106  
                         // com\\googlecode\\sparkleg\\Sparql.g:559:32: ^( CONCAT expressionList )
 20107  
                         {
 20108  10
                         Object root_1 = (Object)adaptor.nil();
 20109  10
                         root_1 = (Object)adaptor.becomeRoot(
 20110  
                         stream_CONCAT.nextNode()
 20111  
                         , root_1);
 20112  
 
 20113  10
                         adaptor.addChild(root_1, stream_expressionList.nextTree());
 20114  
 
 20115  10
                         adaptor.addChild(root_0, root_1);
 20116  
                         }
 20117  
 
 20118  
                     }
 20119  
 
 20120  
 
 20121  10
                     retval.tree = root_0;
 20122  
 
 20123  
                     }
 20124  10
                     break;
 20125  
                 case 16 :
 20126  
                     // com\\googlecode\\sparkleg\\Sparql.g:560:7: subStringExpression
 20127  
                     {
 20128  4
                     pushFollow(FOLLOW_subStringExpression_in_builtInCall5366);
 20129  4
                     subStringExpression444=subStringExpression();
 20130  
 
 20131  4
                     state._fsp--;
 20132  
 
 20133  4
                     stream_subStringExpression.add(subStringExpression444.getTree());
 20134  
 
 20135  
                     // AST REWRITE
 20136  
                     // elements: subStringExpression
 20137  
                     // token labels: 
 20138  
                     // rule labels: retval
 20139  
                     // token list labels: 
 20140  
                     // rule list labels: 
 20141  
                     // wildcard labels: 
 20142  4
                     retval.tree = root_0;
 20143  4
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 20144  
 
 20145  4
                     root_0 = (Object)adaptor.nil();
 20146  
                     // 560:27: -> subStringExpression
 20147  
                     {
 20148  4
                         adaptor.addChild(root_0, stream_subStringExpression.nextTree());
 20149  
 
 20150  
                     }
 20151  
 
 20152  
 
 20153  4
                     retval.tree = root_0;
 20154  
 
 20155  
                     }
 20156  4
                     break;
 20157  
                 case 17 :
 20158  
                     // com\\googlecode\\sparkleg\\Sparql.g:561:7: STRLEN OPEN_BRACE expression CLOSE_BRACE
 20159  
                     {
 20160  2
                     STRLEN445=(Token)match(input,STRLEN,FOLLOW_STRLEN_in_builtInCall5378);  
 20161  2
                     stream_STRLEN.add(STRLEN445);
 20162  
 
 20163  
 
 20164  2
                     OPEN_BRACE446=(Token)match(input,OPEN_BRACE,FOLLOW_OPEN_BRACE_in_builtInCall5380);  
 20165  2
                     stream_OPEN_BRACE.add(OPEN_BRACE446);
 20166  
 
 20167  
 
 20168  2
                     pushFollow(FOLLOW_expression_in_builtInCall5382);
 20169  2
                     expression447=expression();
 20170  
 
 20171  2
                     state._fsp--;
 20172  
 
 20173  2
                     stream_expression.add(expression447.getTree());
 20174  
 
 20175  2
                     CLOSE_BRACE448=(Token)match(input,CLOSE_BRACE,FOLLOW_CLOSE_BRACE_in_builtInCall5384);  
 20176  2
                     stream_CLOSE_BRACE.add(CLOSE_BRACE448);
 20177  
 
 20178  
 
 20179  
                     // AST REWRITE
 20180  
                     // elements: expression, STRLEN
 20181  
                     // token labels: 
 20182  
                     // rule labels: retval
 20183  
                     // token list labels: 
 20184  
                     // rule list labels: 
 20185  
                     // wildcard labels: 
 20186  2
                     retval.tree = root_0;
 20187  2
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 20188  
 
 20189  2
                     root_0 = (Object)adaptor.nil();
 20190  
                     // 561:48: -> ^( STRLEN expression )
 20191  
                     {
 20192  
                         // com\\googlecode\\sparkleg\\Sparql.g:561:51: ^( STRLEN expression )
 20193  
                         {
 20194  2
                         Object root_1 = (Object)adaptor.nil();
 20195  2
                         root_1 = (Object)adaptor.becomeRoot(
 20196  
                         stream_STRLEN.nextNode()
 20197  
                         , root_1);
 20198  
 
 20199  2
                         adaptor.addChild(root_1, stream_expression.nextTree());
 20200  
 
 20201  2
                         adaptor.addChild(root_0, root_1);
 20202  
                         }
 20203  
 
 20204  
                     }
 20205  
 
 20206  
 
 20207  2
                     retval.tree = root_0;
 20208  
 
 20209  
                     }
 20210  2
                     break;
 20211  
                 case 18 :
 20212  
                     // com\\googlecode\\sparkleg\\Sparql.g:562:7: UCASE OPEN_BRACE expression CLOSE_BRACE
 20213  
                     {
 20214  2
                     UCASE449=(Token)match(input,UCASE,FOLLOW_UCASE_in_builtInCall5400);  
 20215  2
                     stream_UCASE.add(UCASE449);
 20216  
 
 20217  
 
 20218  2
                     OPEN_BRACE450=(Token)match(input,OPEN_BRACE,FOLLOW_OPEN_BRACE_in_builtInCall5402);  
 20219  2
                     stream_OPEN_BRACE.add(OPEN_BRACE450);
 20220  
 
 20221  
 
 20222  2
                     pushFollow(FOLLOW_expression_in_builtInCall5404);
 20223  2
                     expression451=expression();
 20224  
 
 20225  2
                     state._fsp--;
 20226  
 
 20227  2
                     stream_expression.add(expression451.getTree());
 20228  
 
 20229  2
                     CLOSE_BRACE452=(Token)match(input,CLOSE_BRACE,FOLLOW_CLOSE_BRACE_in_builtInCall5406);  
 20230  2
                     stream_CLOSE_BRACE.add(CLOSE_BRACE452);
 20231  
 
 20232  
 
 20233  
                     // AST REWRITE
 20234  
                     // elements: expression, UCASE
 20235  
                     // token labels: 
 20236  
                     // rule labels: retval
 20237  
                     // token list labels: 
 20238  
                     // rule list labels: 
 20239  
                     // wildcard labels: 
 20240  2
                     retval.tree = root_0;
 20241  2
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 20242  
 
 20243  2
                     root_0 = (Object)adaptor.nil();
 20244  
                     // 562:47: -> ^( UCASE expression )
 20245  
                     {
 20246  
                         // com\\googlecode\\sparkleg\\Sparql.g:562:50: ^( UCASE expression )
 20247  
                         {
 20248  2
                         Object root_1 = (Object)adaptor.nil();
 20249  2
                         root_1 = (Object)adaptor.becomeRoot(
 20250  
                         stream_UCASE.nextNode()
 20251  
                         , root_1);
 20252  
 
 20253  2
                         adaptor.addChild(root_1, stream_expression.nextTree());
 20254  
 
 20255  2
                         adaptor.addChild(root_0, root_1);
 20256  
                         }
 20257  
 
 20258  
                     }
 20259  
 
 20260  
 
 20261  2
                     retval.tree = root_0;
 20262  
 
 20263  
                     }
 20264  2
                     break;
 20265  
                 case 19 :
 20266  
                     // com\\googlecode\\sparkleg\\Sparql.g:563:7: LCASE OPEN_BRACE expression CLOSE_BRACE
 20267  
                     {
 20268  2
                     LCASE453=(Token)match(input,LCASE,FOLLOW_LCASE_in_builtInCall5422);  
 20269  2
                     stream_LCASE.add(LCASE453);
 20270  
 
 20271  
 
 20272  2
                     OPEN_BRACE454=(Token)match(input,OPEN_BRACE,FOLLOW_OPEN_BRACE_in_builtInCall5424);  
 20273  2
                     stream_OPEN_BRACE.add(OPEN_BRACE454);
 20274  
 
 20275  
 
 20276  2
                     pushFollow(FOLLOW_expression_in_builtInCall5426);
 20277  2
                     expression455=expression();
 20278  
 
 20279  2
                     state._fsp--;
 20280  
 
 20281  2
                     stream_expression.add(expression455.getTree());
 20282  
 
 20283  2
                     CLOSE_BRACE456=(Token)match(input,CLOSE_BRACE,FOLLOW_CLOSE_BRACE_in_builtInCall5428);  
 20284  2
                     stream_CLOSE_BRACE.add(CLOSE_BRACE456);
 20285  
 
 20286  
 
 20287  
                     // AST REWRITE
 20288  
                     // elements: expression, LCASE
 20289  
                     // token labels: 
 20290  
                     // rule labels: retval
 20291  
                     // token list labels: 
 20292  
                     // rule list labels: 
 20293  
                     // wildcard labels: 
 20294  2
                     retval.tree = root_0;
 20295  2
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 20296  
 
 20297  2
                     root_0 = (Object)adaptor.nil();
 20298  
                     // 563:47: -> ^( LCASE expression )
 20299  
                     {
 20300  
                         // com\\googlecode\\sparkleg\\Sparql.g:563:50: ^( LCASE expression )
 20301  
                         {
 20302  2
                         Object root_1 = (Object)adaptor.nil();
 20303  2
                         root_1 = (Object)adaptor.becomeRoot(
 20304  
                         stream_LCASE.nextNode()
 20305  
                         , root_1);
 20306  
 
 20307  2
                         adaptor.addChild(root_1, stream_expression.nextTree());
 20308  
 
 20309  2
                         adaptor.addChild(root_0, root_1);
 20310  
                         }
 20311  
 
 20312  
                     }
 20313  
 
 20314  
 
 20315  2
                     retval.tree = root_0;
 20316  
 
 20317  
                     }
 20318  2
                     break;
 20319  
                 case 20 :
 20320  
                     // com\\googlecode\\sparkleg\\Sparql.g:564:7: ENCODE_FOR_URI OPEN_BRACE expression CLOSE_BRACE
 20321  
                     {
 20322  2
                     ENCODE_FOR_URI457=(Token)match(input,ENCODE_FOR_URI,FOLLOW_ENCODE_FOR_URI_in_builtInCall5444);  
 20323  2
                     stream_ENCODE_FOR_URI.add(ENCODE_FOR_URI457);
 20324  
 
 20325  
 
 20326  2
                     OPEN_BRACE458=(Token)match(input,OPEN_BRACE,FOLLOW_OPEN_BRACE_in_builtInCall5446);  
 20327  2
                     stream_OPEN_BRACE.add(OPEN_BRACE458);
 20328  
 
 20329  
 
 20330  2
                     pushFollow(FOLLOW_expression_in_builtInCall5448);
 20331  2
                     expression459=expression();
 20332  
 
 20333  2
                     state._fsp--;
 20334  
 
 20335  2
                     stream_expression.add(expression459.getTree());
 20336  
 
 20337  2
                     CLOSE_BRACE460=(Token)match(input,CLOSE_BRACE,FOLLOW_CLOSE_BRACE_in_builtInCall5450);  
 20338  2
                     stream_CLOSE_BRACE.add(CLOSE_BRACE460);
 20339  
 
 20340  
 
 20341  
                     // AST REWRITE
 20342  
                     // elements: ENCODE_FOR_URI, expression
 20343  
                     // token labels: 
 20344  
                     // rule labels: retval
 20345  
                     // token list labels: 
 20346  
                     // rule list labels: 
 20347  
                     // wildcard labels: 
 20348  2
                     retval.tree = root_0;
 20349  2
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 20350  
 
 20351  2
                     root_0 = (Object)adaptor.nil();
 20352  
                     // 564:56: -> ^( ENCODE_FOR_URI expression )
 20353  
                     {
 20354  
                         // com\\googlecode\\sparkleg\\Sparql.g:564:59: ^( ENCODE_FOR_URI expression )
 20355  
                         {
 20356  2
                         Object root_1 = (Object)adaptor.nil();
 20357  2
                         root_1 = (Object)adaptor.becomeRoot(
 20358  
                         stream_ENCODE_FOR_URI.nextNode()
 20359  
                         , root_1);
 20360  
 
 20361  2
                         adaptor.addChild(root_1, stream_expression.nextTree());
 20362  
 
 20363  2
                         adaptor.addChild(root_0, root_1);
 20364  
                         }
 20365  
 
 20366  
                     }
 20367  
 
 20368  
 
 20369  2
                     retval.tree = root_0;
 20370  
 
 20371  
                     }
 20372  2
                     break;
 20373  
                 case 21 :
 20374  
                     // com\\googlecode\\sparkleg\\Sparql.g:565:7: CONTAINS OPEN_BRACE expression COMMA expression CLOSE_BRACE
 20375  
                     {
 20376  2
                     CONTAINS461=(Token)match(input,CONTAINS,FOLLOW_CONTAINS_in_builtInCall5466);  
 20377  2
                     stream_CONTAINS.add(CONTAINS461);
 20378  
 
 20379  
 
 20380  2
                     OPEN_BRACE462=(Token)match(input,OPEN_BRACE,FOLLOW_OPEN_BRACE_in_builtInCall5468);  
 20381  2
                     stream_OPEN_BRACE.add(OPEN_BRACE462);
 20382  
 
 20383  
 
 20384  2
                     pushFollow(FOLLOW_expression_in_builtInCall5470);
 20385  2
                     expression463=expression();
 20386  
 
 20387  2
                     state._fsp--;
 20388  
 
 20389  2
                     stream_expression.add(expression463.getTree());
 20390  
 
 20391  2
                     COMMA464=(Token)match(input,COMMA,FOLLOW_COMMA_in_builtInCall5472);  
 20392  2
                     stream_COMMA.add(COMMA464);
 20393  
 
 20394  
 
 20395  2
                     pushFollow(FOLLOW_expression_in_builtInCall5474);
 20396  2
                     expression465=expression();
 20397  
 
 20398  2
                     state._fsp--;
 20399  
 
 20400  2
                     stream_expression.add(expression465.getTree());
 20401  
 
 20402  2
                     CLOSE_BRACE466=(Token)match(input,CLOSE_BRACE,FOLLOW_CLOSE_BRACE_in_builtInCall5476);  
 20403  2
                     stream_CLOSE_BRACE.add(CLOSE_BRACE466);
 20404  
 
 20405  
 
 20406  
                     // AST REWRITE
 20407  
                     // elements: expression, expression, CONTAINS
 20408  
                     // token labels: 
 20409  
                     // rule labels: retval
 20410  
                     // token list labels: 
 20411  
                     // rule list labels: 
 20412  
                     // wildcard labels: 
 20413  2
                     retval.tree = root_0;
 20414  2
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 20415  
 
 20416  2
                     root_0 = (Object)adaptor.nil();
 20417  
                     // 565:67: -> ^( CONTAINS expression expression )
 20418  
                     {
 20419  
                         // com\\googlecode\\sparkleg\\Sparql.g:565:70: ^( CONTAINS expression expression )
 20420  
                         {
 20421  2
                         Object root_1 = (Object)adaptor.nil();
 20422  2
                         root_1 = (Object)adaptor.becomeRoot(
 20423  
                         stream_CONTAINS.nextNode()
 20424  
                         , root_1);
 20425  
 
 20426  2
                         adaptor.addChild(root_1, stream_expression.nextTree());
 20427  
 
 20428  2
                         adaptor.addChild(root_1, stream_expression.nextTree());
 20429  
 
 20430  2
                         adaptor.addChild(root_0, root_1);
 20431  
                         }
 20432  
 
 20433  
                     }
 20434  
 
 20435  
 
 20436  2
                     retval.tree = root_0;
 20437  
 
 20438  
                     }
 20439  2
                     break;
 20440  
                 case 22 :
 20441  
                     // com\\googlecode\\sparkleg\\Sparql.g:566:7: STRSTARTS OPEN_BRACE expression COMMA expression CLOSE_BRACE
 20442  
                     {
 20443  2
                     STRSTARTS467=(Token)match(input,STRSTARTS,FOLLOW_STRSTARTS_in_builtInCall5494);  
 20444  2
                     stream_STRSTARTS.add(STRSTARTS467);
 20445  
 
 20446  
 
 20447  2
                     OPEN_BRACE468=(Token)match(input,OPEN_BRACE,FOLLOW_OPEN_BRACE_in_builtInCall5496);  
 20448  2
                     stream_OPEN_BRACE.add(OPEN_BRACE468);
 20449  
 
 20450  
 
 20451  2
                     pushFollow(FOLLOW_expression_in_builtInCall5498);
 20452  2
                     expression469=expression();
 20453  
 
 20454  2
                     state._fsp--;
 20455  
 
 20456  2
                     stream_expression.add(expression469.getTree());
 20457  
 
 20458  2
                     COMMA470=(Token)match(input,COMMA,FOLLOW_COMMA_in_builtInCall5500);  
 20459  2
                     stream_COMMA.add(COMMA470);
 20460  
 
 20461  
 
 20462  2
                     pushFollow(FOLLOW_expression_in_builtInCall5502);
 20463  2
                     expression471=expression();
 20464  
 
 20465  2
                     state._fsp--;
 20466  
 
 20467  2
                     stream_expression.add(expression471.getTree());
 20468  
 
 20469  2
                     CLOSE_BRACE472=(Token)match(input,CLOSE_BRACE,FOLLOW_CLOSE_BRACE_in_builtInCall5504);  
 20470  2
                     stream_CLOSE_BRACE.add(CLOSE_BRACE472);
 20471  
 
 20472  
 
 20473  
                     // AST REWRITE
 20474  
                     // elements: expression, expression, STRSTARTS
 20475  
                     // token labels: 
 20476  
                     // rule labels: retval
 20477  
                     // token list labels: 
 20478  
                     // rule list labels: 
 20479  
                     // wildcard labels: 
 20480  2
                     retval.tree = root_0;
 20481  2
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 20482  
 
 20483  2
                     root_0 = (Object)adaptor.nil();
 20484  
                     // 566:68: -> ^( STRSTARTS expression expression )
 20485  
                     {
 20486  
                         // com\\googlecode\\sparkleg\\Sparql.g:566:71: ^( STRSTARTS expression expression )
 20487  
                         {
 20488  2
                         Object root_1 = (Object)adaptor.nil();
 20489  2
                         root_1 = (Object)adaptor.becomeRoot(
 20490  
                         stream_STRSTARTS.nextNode()
 20491  
                         , root_1);
 20492  
 
 20493  2
                         adaptor.addChild(root_1, stream_expression.nextTree());
 20494  
 
 20495  2
                         adaptor.addChild(root_1, stream_expression.nextTree());
 20496  
 
 20497  2
                         adaptor.addChild(root_0, root_1);
 20498  
                         }
 20499  
 
 20500  
                     }
 20501  
 
 20502  
 
 20503  2
                     retval.tree = root_0;
 20504  
 
 20505  
                     }
 20506  2
                     break;
 20507  
                 case 23 :
 20508  
                     // com\\googlecode\\sparkleg\\Sparql.g:567:7: STRENDS OPEN_BRACE expression COMMA expression CLOSE_BRACE
 20509  
                     {
 20510  2
                     STRENDS473=(Token)match(input,STRENDS,FOLLOW_STRENDS_in_builtInCall5522);  
 20511  2
                     stream_STRENDS.add(STRENDS473);
 20512  
 
 20513  
 
 20514  2
                     OPEN_BRACE474=(Token)match(input,OPEN_BRACE,FOLLOW_OPEN_BRACE_in_builtInCall5524);  
 20515  2
                     stream_OPEN_BRACE.add(OPEN_BRACE474);
 20516  
 
 20517  
 
 20518  2
                     pushFollow(FOLLOW_expression_in_builtInCall5526);
 20519  2
                     expression475=expression();
 20520  
 
 20521  2
                     state._fsp--;
 20522  
 
 20523  2
                     stream_expression.add(expression475.getTree());
 20524  
 
 20525  2
                     COMMA476=(Token)match(input,COMMA,FOLLOW_COMMA_in_builtInCall5528);  
 20526  2
                     stream_COMMA.add(COMMA476);
 20527  
 
 20528  
 
 20529  2
                     pushFollow(FOLLOW_expression_in_builtInCall5530);
 20530  2
                     expression477=expression();
 20531  
 
 20532  2
                     state._fsp--;
 20533  
 
 20534  2
                     stream_expression.add(expression477.getTree());
 20535  
 
 20536  2
                     CLOSE_BRACE478=(Token)match(input,CLOSE_BRACE,FOLLOW_CLOSE_BRACE_in_builtInCall5532);  
 20537  2
                     stream_CLOSE_BRACE.add(CLOSE_BRACE478);
 20538  
 
 20539  
 
 20540  
                     // AST REWRITE
 20541  
                     // elements: expression, STRENDS, expression
 20542  
                     // token labels: 
 20543  
                     // rule labels: retval
 20544  
                     // token list labels: 
 20545  
                     // rule list labels: 
 20546  
                     // wildcard labels: 
 20547  2
                     retval.tree = root_0;
 20548  2
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 20549  
 
 20550  2
                     root_0 = (Object)adaptor.nil();
 20551  
                     // 567:66: -> ^( STRENDS expression expression )
 20552  
                     {
 20553  
                         // com\\googlecode\\sparkleg\\Sparql.g:567:69: ^( STRENDS expression expression )
 20554  
                         {
 20555  2
                         Object root_1 = (Object)adaptor.nil();
 20556  2
                         root_1 = (Object)adaptor.becomeRoot(
 20557  
                         stream_STRENDS.nextNode()
 20558  
                         , root_1);
 20559  
 
 20560  2
                         adaptor.addChild(root_1, stream_expression.nextTree());
 20561  
 
 20562  2
                         adaptor.addChild(root_1, stream_expression.nextTree());
 20563  
 
 20564  2
                         adaptor.addChild(root_0, root_1);
 20565  
                         }
 20566  
 
 20567  
                     }
 20568  
 
 20569  
 
 20570  2
                     retval.tree = root_0;
 20571  
 
 20572  
                     }
 20573  2
                     break;
 20574  
                 case 24 :
 20575  
                     // com\\googlecode\\sparkleg\\Sparql.g:568:7: STRBEFORE OPEN_BRACE expression COMMA expression CLOSE_BRACE
 20576  
                     {
 20577  2
                     STRBEFORE479=(Token)match(input,STRBEFORE,FOLLOW_STRBEFORE_in_builtInCall5550);  
 20578  2
                     stream_STRBEFORE.add(STRBEFORE479);
 20579  
 
 20580  
 
 20581  2
                     OPEN_BRACE480=(Token)match(input,OPEN_BRACE,FOLLOW_OPEN_BRACE_in_builtInCall5552);  
 20582  2
                     stream_OPEN_BRACE.add(OPEN_BRACE480);
 20583  
 
 20584  
 
 20585  2
                     pushFollow(FOLLOW_expression_in_builtInCall5554);
 20586  2
                     expression481=expression();
 20587  
 
 20588  2
                     state._fsp--;
 20589  
 
 20590  2
                     stream_expression.add(expression481.getTree());
 20591  
 
 20592  2
                     COMMA482=(Token)match(input,COMMA,FOLLOW_COMMA_in_builtInCall5556);  
 20593  2
                     stream_COMMA.add(COMMA482);
 20594  
 
 20595  
 
 20596  2
                     pushFollow(FOLLOW_expression_in_builtInCall5558);
 20597  2
                     expression483=expression();
 20598  
 
 20599  2
                     state._fsp--;
 20600  
 
 20601  2
                     stream_expression.add(expression483.getTree());
 20602  
 
 20603  2
                     CLOSE_BRACE484=(Token)match(input,CLOSE_BRACE,FOLLOW_CLOSE_BRACE_in_builtInCall5560);  
 20604  2
                     stream_CLOSE_BRACE.add(CLOSE_BRACE484);
 20605  
 
 20606  
 
 20607  
                     // AST REWRITE
 20608  
                     // elements: STRBEFORE, expression, expression
 20609  
                     // token labels: 
 20610  
                     // rule labels: retval
 20611  
                     // token list labels: 
 20612  
                     // rule list labels: 
 20613  
                     // wildcard labels: 
 20614  2
                     retval.tree = root_0;
 20615  2
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 20616  
 
 20617  2
                     root_0 = (Object)adaptor.nil();
 20618  
                     // 568:68: -> ^( STRBEFORE expression expression )
 20619  
                     {
 20620  
                         // com\\googlecode\\sparkleg\\Sparql.g:568:71: ^( STRBEFORE expression expression )
 20621  
                         {
 20622  2
                         Object root_1 = (Object)adaptor.nil();
 20623  2
                         root_1 = (Object)adaptor.becomeRoot(
 20624  
                         stream_STRBEFORE.nextNode()
 20625  
                         , root_1);
 20626  
 
 20627  2
                         adaptor.addChild(root_1, stream_expression.nextTree());
 20628  
 
 20629  2
                         adaptor.addChild(root_1, stream_expression.nextTree());
 20630  
 
 20631  2
                         adaptor.addChild(root_0, root_1);
 20632  
                         }
 20633  
 
 20634  
                     }
 20635  
 
 20636  
 
 20637  2
                     retval.tree = root_0;
 20638  
 
 20639  
                     }
 20640  2
                     break;
 20641  
                 case 25 :
 20642  
                     // com\\googlecode\\sparkleg\\Sparql.g:569:7: STRAFTER OPEN_BRACE expression COMMA expression CLOSE_BRACE
 20643  
                     {
 20644  2
                     STRAFTER485=(Token)match(input,STRAFTER,FOLLOW_STRAFTER_in_builtInCall5578);  
 20645  2
                     stream_STRAFTER.add(STRAFTER485);
 20646  
 
 20647  
 
 20648  2
                     OPEN_BRACE486=(Token)match(input,OPEN_BRACE,FOLLOW_OPEN_BRACE_in_builtInCall5580);  
 20649  2
                     stream_OPEN_BRACE.add(OPEN_BRACE486);
 20650  
 
 20651  
 
 20652  2
                     pushFollow(FOLLOW_expression_in_builtInCall5582);
 20653  2
                     expression487=expression();
 20654  
 
 20655  2
                     state._fsp--;
 20656  
 
 20657  2
                     stream_expression.add(expression487.getTree());
 20658  
 
 20659  2
                     COMMA488=(Token)match(input,COMMA,FOLLOW_COMMA_in_builtInCall5584);  
 20660  2
                     stream_COMMA.add(COMMA488);
 20661  
 
 20662  
 
 20663  2
                     pushFollow(FOLLOW_expression_in_builtInCall5586);
 20664  2
                     expression489=expression();
 20665  
 
 20666  2
                     state._fsp--;
 20667  
 
 20668  2
                     stream_expression.add(expression489.getTree());
 20669  
 
 20670  2
                     CLOSE_BRACE490=(Token)match(input,CLOSE_BRACE,FOLLOW_CLOSE_BRACE_in_builtInCall5588);  
 20671  2
                     stream_CLOSE_BRACE.add(CLOSE_BRACE490);
 20672  
 
 20673  
 
 20674  
                     // AST REWRITE
 20675  
                     // elements: expression, STRAFTER, expression
 20676  
                     // token labels: 
 20677  
                     // rule labels: retval
 20678  
                     // token list labels: 
 20679  
                     // rule list labels: 
 20680  
                     // wildcard labels: 
 20681  2
                     retval.tree = root_0;
 20682  2
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 20683  
 
 20684  2
                     root_0 = (Object)adaptor.nil();
 20685  
                     // 569:67: -> ^( STRAFTER expression expression )
 20686  
                     {
 20687  
                         // com\\googlecode\\sparkleg\\Sparql.g:569:70: ^( STRAFTER expression expression )
 20688  
                         {
 20689  2
                         Object root_1 = (Object)adaptor.nil();
 20690  2
                         root_1 = (Object)adaptor.becomeRoot(
 20691  
                         stream_STRAFTER.nextNode()
 20692  
                         , root_1);
 20693  
 
 20694  2
                         adaptor.addChild(root_1, stream_expression.nextTree());
 20695  
 
 20696  2
                         adaptor.addChild(root_1, stream_expression.nextTree());
 20697  
 
 20698  2
                         adaptor.addChild(root_0, root_1);
 20699  
                         }
 20700  
 
 20701  
                     }
 20702  
 
 20703  
 
 20704  2
                     retval.tree = root_0;
 20705  
 
 20706  
                     }
 20707  2
                     break;
 20708  
                 case 26 :
 20709  
                     // com\\googlecode\\sparkleg\\Sparql.g:570:7: REPLACE OPEN_BRACE expression COMMA expression COMMA expression CLOSE_BRACE
 20710  
                     {
 20711  6
                     REPLACE491=(Token)match(input,REPLACE,FOLLOW_REPLACE_in_builtInCall5606);  
 20712  6
                     stream_REPLACE.add(REPLACE491);
 20713  
 
 20714  
 
 20715  6
                     OPEN_BRACE492=(Token)match(input,OPEN_BRACE,FOLLOW_OPEN_BRACE_in_builtInCall5608);  
 20716  6
                     stream_OPEN_BRACE.add(OPEN_BRACE492);
 20717  
 
 20718  
 
 20719  6
                     pushFollow(FOLLOW_expression_in_builtInCall5610);
 20720  6
                     expression493=expression();
 20721  
 
 20722  6
                     state._fsp--;
 20723  
 
 20724  6
                     stream_expression.add(expression493.getTree());
 20725  
 
 20726  6
                     COMMA494=(Token)match(input,COMMA,FOLLOW_COMMA_in_builtInCall5612);  
 20727  6
                     stream_COMMA.add(COMMA494);
 20728  
 
 20729  
 
 20730  6
                     pushFollow(FOLLOW_expression_in_builtInCall5614);
 20731  6
                     expression495=expression();
 20732  
 
 20733  6
                     state._fsp--;
 20734  
 
 20735  6
                     stream_expression.add(expression495.getTree());
 20736  
 
 20737  6
                     COMMA496=(Token)match(input,COMMA,FOLLOW_COMMA_in_builtInCall5616);  
 20738  6
                     stream_COMMA.add(COMMA496);
 20739  
 
 20740  
 
 20741  6
                     pushFollow(FOLLOW_expression_in_builtInCall5618);
 20742  6
                     expression497=expression();
 20743  
 
 20744  6
                     state._fsp--;
 20745  
 
 20746  6
                     stream_expression.add(expression497.getTree());
 20747  
 
 20748  6
                     CLOSE_BRACE498=(Token)match(input,CLOSE_BRACE,FOLLOW_CLOSE_BRACE_in_builtInCall5620);  
 20749  6
                     stream_CLOSE_BRACE.add(CLOSE_BRACE498);
 20750  
 
 20751  
 
 20752  
                     // AST REWRITE
 20753  
                     // elements: expression, expression, REPLACE, expression
 20754  
                     // token labels: 
 20755  
                     // rule labels: retval
 20756  
                     // token list labels: 
 20757  
                     // rule list labels: 
 20758  
                     // wildcard labels: 
 20759  6
                     retval.tree = root_0;
 20760  6
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 20761  
 
 20762  6
                     root_0 = (Object)adaptor.nil();
 20763  
                     // 570:83: -> ^( REPLACE expression expression expression )
 20764  
                     {
 20765  
                         // com\\googlecode\\sparkleg\\Sparql.g:570:86: ^( REPLACE expression expression expression )
 20766  
                         {
 20767  6
                         Object root_1 = (Object)adaptor.nil();
 20768  6
                         root_1 = (Object)adaptor.becomeRoot(
 20769  
                         stream_REPLACE.nextNode()
 20770  
                         , root_1);
 20771  
 
 20772  6
                         adaptor.addChild(root_1, stream_expression.nextTree());
 20773  
 
 20774  6
                         adaptor.addChild(root_1, stream_expression.nextTree());
 20775  
 
 20776  6
                         adaptor.addChild(root_1, stream_expression.nextTree());
 20777  
 
 20778  6
                         adaptor.addChild(root_0, root_1);
 20779  
                         }
 20780  
 
 20781  
                     }
 20782  
 
 20783  
 
 20784  6
                     retval.tree = root_0;
 20785  
 
 20786  
                     }
 20787  6
                     break;
 20788  
                 case 27 :
 20789  
                     // com\\googlecode\\sparkleg\\Sparql.g:571:7: YEAR OPEN_BRACE expression CLOSE_BRACE
 20790  
                     {
 20791  2
                     YEAR499=(Token)match(input,YEAR,FOLLOW_YEAR_in_builtInCall5640);  
 20792  2
                     stream_YEAR.add(YEAR499);
 20793  
 
 20794  
 
 20795  2
                     OPEN_BRACE500=(Token)match(input,OPEN_BRACE,FOLLOW_OPEN_BRACE_in_builtInCall5642);  
 20796  2
                     stream_OPEN_BRACE.add(OPEN_BRACE500);
 20797  
 
 20798  
 
 20799  2
                     pushFollow(FOLLOW_expression_in_builtInCall5644);
 20800  2
                     expression501=expression();
 20801  
 
 20802  2
                     state._fsp--;
 20803  
 
 20804  2
                     stream_expression.add(expression501.getTree());
 20805  
 
 20806  2
                     CLOSE_BRACE502=(Token)match(input,CLOSE_BRACE,FOLLOW_CLOSE_BRACE_in_builtInCall5646);  
 20807  2
                     stream_CLOSE_BRACE.add(CLOSE_BRACE502);
 20808  
 
 20809  
 
 20810  
                     // AST REWRITE
 20811  
                     // elements: expression, YEAR
 20812  
                     // token labels: 
 20813  
                     // rule labels: retval
 20814  
                     // token list labels: 
 20815  
                     // rule list labels: 
 20816  
                     // wildcard labels: 
 20817  2
                     retval.tree = root_0;
 20818  2
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 20819  
 
 20820  2
                     root_0 = (Object)adaptor.nil();
 20821  
                     // 571:46: -> ^( YEAR expression )
 20822  
                     {
 20823  
                         // com\\googlecode\\sparkleg\\Sparql.g:571:49: ^( YEAR expression )
 20824  
                         {
 20825  2
                         Object root_1 = (Object)adaptor.nil();
 20826  2
                         root_1 = (Object)adaptor.becomeRoot(
 20827  
                         stream_YEAR.nextNode()
 20828  
                         , root_1);
 20829  
 
 20830  2
                         adaptor.addChild(root_1, stream_expression.nextTree());
 20831  
 
 20832  2
                         adaptor.addChild(root_0, root_1);
 20833  
                         }
 20834  
 
 20835  
                     }
 20836  
 
 20837  
 
 20838  2
                     retval.tree = root_0;
 20839  
 
 20840  
                     }
 20841  2
                     break;
 20842  
                 case 28 :
 20843  
                     // com\\googlecode\\sparkleg\\Sparql.g:572:7: MONTH OPEN_BRACE expression CLOSE_BRACE
 20844  
                     {
 20845  2
                     MONTH503=(Token)match(input,MONTH,FOLLOW_MONTH_in_builtInCall5662);  
 20846  2
                     stream_MONTH.add(MONTH503);
 20847  
 
 20848  
 
 20849  2
                     OPEN_BRACE504=(Token)match(input,OPEN_BRACE,FOLLOW_OPEN_BRACE_in_builtInCall5664);  
 20850  2
                     stream_OPEN_BRACE.add(OPEN_BRACE504);
 20851  
 
 20852  
 
 20853  2
                     pushFollow(FOLLOW_expression_in_builtInCall5666);
 20854  2
                     expression505=expression();
 20855  
 
 20856  2
                     state._fsp--;
 20857  
 
 20858  2
                     stream_expression.add(expression505.getTree());
 20859  
 
 20860  2
                     CLOSE_BRACE506=(Token)match(input,CLOSE_BRACE,FOLLOW_CLOSE_BRACE_in_builtInCall5668);  
 20861  2
                     stream_CLOSE_BRACE.add(CLOSE_BRACE506);
 20862  
 
 20863  
 
 20864  
                     // AST REWRITE
 20865  
                     // elements: expression, MONTH
 20866  
                     // token labels: 
 20867  
                     // rule labels: retval
 20868  
                     // token list labels: 
 20869  
                     // rule list labels: 
 20870  
                     // wildcard labels: 
 20871  2
                     retval.tree = root_0;
 20872  2
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 20873  
 
 20874  2
                     root_0 = (Object)adaptor.nil();
 20875  
                     // 572:47: -> ^( MONTH expression )
 20876  
                     {
 20877  
                         // com\\googlecode\\sparkleg\\Sparql.g:572:50: ^( MONTH expression )
 20878  
                         {
 20879  2
                         Object root_1 = (Object)adaptor.nil();
 20880  2
                         root_1 = (Object)adaptor.becomeRoot(
 20881  
                         stream_MONTH.nextNode()
 20882  
                         , root_1);
 20883  
 
 20884  2
                         adaptor.addChild(root_1, stream_expression.nextTree());
 20885  
 
 20886  2
                         adaptor.addChild(root_0, root_1);
 20887  
                         }
 20888  
 
 20889  
                     }
 20890  
 
 20891  
 
 20892  2
                     retval.tree = root_0;
 20893  
 
 20894  
                     }
 20895  2
                     break;
 20896  
                 case 29 :
 20897  
                     // com\\googlecode\\sparkleg\\Sparql.g:573:7: DAY OPEN_BRACE expression CLOSE_BRACE
 20898  
                     {
 20899  2
                     DAY507=(Token)match(input,DAY,FOLLOW_DAY_in_builtInCall5684);  
 20900  2
                     stream_DAY.add(DAY507);
 20901  
 
 20902  
 
 20903  2
                     OPEN_BRACE508=(Token)match(input,OPEN_BRACE,FOLLOW_OPEN_BRACE_in_builtInCall5686);  
 20904  2
                     stream_OPEN_BRACE.add(OPEN_BRACE508);
 20905  
 
 20906  
 
 20907  2
                     pushFollow(FOLLOW_expression_in_builtInCall5688);
 20908  2
                     expression509=expression();
 20909  
 
 20910  2
                     state._fsp--;
 20911  
 
 20912  2
                     stream_expression.add(expression509.getTree());
 20913  
 
 20914  2
                     CLOSE_BRACE510=(Token)match(input,CLOSE_BRACE,FOLLOW_CLOSE_BRACE_in_builtInCall5690);  
 20915  2
                     stream_CLOSE_BRACE.add(CLOSE_BRACE510);
 20916  
 
 20917  
 
 20918  
                     // AST REWRITE
 20919  
                     // elements: expression, DAY
 20920  
                     // token labels: 
 20921  
                     // rule labels: retval
 20922  
                     // token list labels: 
 20923  
                     // rule list labels: 
 20924  
                     // wildcard labels: 
 20925  2
                     retval.tree = root_0;
 20926  2
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 20927  
 
 20928  2
                     root_0 = (Object)adaptor.nil();
 20929  
                     // 573:45: -> ^( DAY expression )
 20930  
                     {
 20931  
                         // com\\googlecode\\sparkleg\\Sparql.g:573:48: ^( DAY expression )
 20932  
                         {
 20933  2
                         Object root_1 = (Object)adaptor.nil();
 20934  2
                         root_1 = (Object)adaptor.becomeRoot(
 20935  
                         stream_DAY.nextNode()
 20936  
                         , root_1);
 20937  
 
 20938  2
                         adaptor.addChild(root_1, stream_expression.nextTree());
 20939  
 
 20940  2
                         adaptor.addChild(root_0, root_1);
 20941  
                         }
 20942  
 
 20943  
                     }
 20944  
 
 20945  
 
 20946  2
                     retval.tree = root_0;
 20947  
 
 20948  
                     }
 20949  2
                     break;
 20950  
                 case 30 :
 20951  
                     // com\\googlecode\\sparkleg\\Sparql.g:574:7: HOURS OPEN_BRACE expression CLOSE_BRACE
 20952  
                     {
 20953  2
                     HOURS511=(Token)match(input,HOURS,FOLLOW_HOURS_in_builtInCall5706);  
 20954  2
                     stream_HOURS.add(HOURS511);
 20955  
 
 20956  
 
 20957  2
                     OPEN_BRACE512=(Token)match(input,OPEN_BRACE,FOLLOW_OPEN_BRACE_in_builtInCall5708);  
 20958  2
                     stream_OPEN_BRACE.add(OPEN_BRACE512);
 20959  
 
 20960  
 
 20961  2
                     pushFollow(FOLLOW_expression_in_builtInCall5710);
 20962  2
                     expression513=expression();
 20963  
 
 20964  2
                     state._fsp--;
 20965  
 
 20966  2
                     stream_expression.add(expression513.getTree());
 20967  
 
 20968  2
                     CLOSE_BRACE514=(Token)match(input,CLOSE_BRACE,FOLLOW_CLOSE_BRACE_in_builtInCall5712);  
 20969  2
                     stream_CLOSE_BRACE.add(CLOSE_BRACE514);
 20970  
 
 20971  
 
 20972  
                     // AST REWRITE
 20973  
                     // elements: expression, HOURS
 20974  
                     // token labels: 
 20975  
                     // rule labels: retval
 20976  
                     // token list labels: 
 20977  
                     // rule list labels: 
 20978  
                     // wildcard labels: 
 20979  2
                     retval.tree = root_0;
 20980  2
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 20981  
 
 20982  2
                     root_0 = (Object)adaptor.nil();
 20983  
                     // 574:47: -> ^( HOURS expression )
 20984  
                     {
 20985  
                         // com\\googlecode\\sparkleg\\Sparql.g:574:50: ^( HOURS expression )
 20986  
                         {
 20987  2
                         Object root_1 = (Object)adaptor.nil();
 20988  2
                         root_1 = (Object)adaptor.becomeRoot(
 20989  
                         stream_HOURS.nextNode()
 20990  
                         , root_1);
 20991  
 
 20992  2
                         adaptor.addChild(root_1, stream_expression.nextTree());
 20993  
 
 20994  2
                         adaptor.addChild(root_0, root_1);
 20995  
                         }
 20996  
 
 20997  
                     }
 20998  
 
 20999  
 
 21000  2
                     retval.tree = root_0;
 21001  
 
 21002  
                     }
 21003  2
                     break;
 21004  
                 case 31 :
 21005  
                     // com\\googlecode\\sparkleg\\Sparql.g:575:7: MINUTES OPEN_BRACE expression CLOSE_BRACE
 21006  
                     {
 21007  2
                     MINUTES515=(Token)match(input,MINUTES,FOLLOW_MINUTES_in_builtInCall5728);  
 21008  2
                     stream_MINUTES.add(MINUTES515);
 21009  
 
 21010  
 
 21011  2
                     OPEN_BRACE516=(Token)match(input,OPEN_BRACE,FOLLOW_OPEN_BRACE_in_builtInCall5730);  
 21012  2
                     stream_OPEN_BRACE.add(OPEN_BRACE516);
 21013  
 
 21014  
 
 21015  2
                     pushFollow(FOLLOW_expression_in_builtInCall5732);
 21016  2
                     expression517=expression();
 21017  
 
 21018  2
                     state._fsp--;
 21019  
 
 21020  2
                     stream_expression.add(expression517.getTree());
 21021  
 
 21022  2
                     CLOSE_BRACE518=(Token)match(input,CLOSE_BRACE,FOLLOW_CLOSE_BRACE_in_builtInCall5734);  
 21023  2
                     stream_CLOSE_BRACE.add(CLOSE_BRACE518);
 21024  
 
 21025  
 
 21026  
                     // AST REWRITE
 21027  
                     // elements: MINUTES, expression
 21028  
                     // token labels: 
 21029  
                     // rule labels: retval
 21030  
                     // token list labels: 
 21031  
                     // rule list labels: 
 21032  
                     // wildcard labels: 
 21033  2
                     retval.tree = root_0;
 21034  2
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 21035  
 
 21036  2
                     root_0 = (Object)adaptor.nil();
 21037  
                     // 575:49: -> ^( MINUTES expression )
 21038  
                     {
 21039  
                         // com\\googlecode\\sparkleg\\Sparql.g:575:52: ^( MINUTES expression )
 21040  
                         {
 21041  2
                         Object root_1 = (Object)adaptor.nil();
 21042  2
                         root_1 = (Object)adaptor.becomeRoot(
 21043  
                         stream_MINUTES.nextNode()
 21044  
                         , root_1);
 21045  
 
 21046  2
                         adaptor.addChild(root_1, stream_expression.nextTree());
 21047  
 
 21048  2
                         adaptor.addChild(root_0, root_1);
 21049  
                         }
 21050  
 
 21051  
                     }
 21052  
 
 21053  
 
 21054  2
                     retval.tree = root_0;
 21055  
 
 21056  
                     }
 21057  2
                     break;
 21058  
                 case 32 :
 21059  
                     // com\\googlecode\\sparkleg\\Sparql.g:576:7: SECONDS OPEN_BRACE expression CLOSE_BRACE
 21060  
                     {
 21061  2
                     SECONDS519=(Token)match(input,SECONDS,FOLLOW_SECONDS_in_builtInCall5750);  
 21062  2
                     stream_SECONDS.add(SECONDS519);
 21063  
 
 21064  
 
 21065  2
                     OPEN_BRACE520=(Token)match(input,OPEN_BRACE,FOLLOW_OPEN_BRACE_in_builtInCall5752);  
 21066  2
                     stream_OPEN_BRACE.add(OPEN_BRACE520);
 21067  
 
 21068  
 
 21069  2
                     pushFollow(FOLLOW_expression_in_builtInCall5754);
 21070  2
                     expression521=expression();
 21071  
 
 21072  2
                     state._fsp--;
 21073  
 
 21074  2
                     stream_expression.add(expression521.getTree());
 21075  
 
 21076  2
                     CLOSE_BRACE522=(Token)match(input,CLOSE_BRACE,FOLLOW_CLOSE_BRACE_in_builtInCall5756);  
 21077  2
                     stream_CLOSE_BRACE.add(CLOSE_BRACE522);
 21078  
 
 21079  
 
 21080  
                     // AST REWRITE
 21081  
                     // elements: expression, SECONDS
 21082  
                     // token labels: 
 21083  
                     // rule labels: retval
 21084  
                     // token list labels: 
 21085  
                     // rule list labels: 
 21086  
                     // wildcard labels: 
 21087  2
                     retval.tree = root_0;
 21088  2
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 21089  
 
 21090  2
                     root_0 = (Object)adaptor.nil();
 21091  
                     // 576:49: -> ^( SECONDS expression )
 21092  
                     {
 21093  
                         // com\\googlecode\\sparkleg\\Sparql.g:576:52: ^( SECONDS expression )
 21094  
                         {
 21095  2
                         Object root_1 = (Object)adaptor.nil();
 21096  2
                         root_1 = (Object)adaptor.becomeRoot(
 21097  
                         stream_SECONDS.nextNode()
 21098  
                         , root_1);
 21099  
 
 21100  2
                         adaptor.addChild(root_1, stream_expression.nextTree());
 21101  
 
 21102  2
                         adaptor.addChild(root_0, root_1);
 21103  
                         }
 21104  
 
 21105  
                     }
 21106  
 
 21107  
 
 21108  2
                     retval.tree = root_0;
 21109  
 
 21110  
                     }
 21111  2
                     break;
 21112  
                 case 33 :
 21113  
                     // com\\googlecode\\sparkleg\\Sparql.g:577:7: TIMEZONE OPEN_BRACE expression CLOSE_BRACE
 21114  
                     {
 21115  2
                     TIMEZONE523=(Token)match(input,TIMEZONE,FOLLOW_TIMEZONE_in_builtInCall5772);  
 21116  2
                     stream_TIMEZONE.add(TIMEZONE523);
 21117  
 
 21118  
 
 21119  2
                     OPEN_BRACE524=(Token)match(input,OPEN_BRACE,FOLLOW_OPEN_BRACE_in_builtInCall5774);  
 21120  2
                     stream_OPEN_BRACE.add(OPEN_BRACE524);
 21121  
 
 21122  
 
 21123  2
                     pushFollow(FOLLOW_expression_in_builtInCall5776);
 21124  2
                     expression525=expression();
 21125  
 
 21126  2
                     state._fsp--;
 21127  
 
 21128  2
                     stream_expression.add(expression525.getTree());
 21129  
 
 21130  2
                     CLOSE_BRACE526=(Token)match(input,CLOSE_BRACE,FOLLOW_CLOSE_BRACE_in_builtInCall5778);  
 21131  2
                     stream_CLOSE_BRACE.add(CLOSE_BRACE526);
 21132  
 
 21133  
 
 21134  
                     // AST REWRITE
 21135  
                     // elements: TIMEZONE, expression
 21136  
                     // token labels: 
 21137  
                     // rule labels: retval
 21138  
                     // token list labels: 
 21139  
                     // rule list labels: 
 21140  
                     // wildcard labels: 
 21141  2
                     retval.tree = root_0;
 21142  2
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 21143  
 
 21144  2
                     root_0 = (Object)adaptor.nil();
 21145  
                     // 577:50: -> ^( TIMEZONE expression )
 21146  
                     {
 21147  
                         // com\\googlecode\\sparkleg\\Sparql.g:577:53: ^( TIMEZONE expression )
 21148  
                         {
 21149  2
                         Object root_1 = (Object)adaptor.nil();
 21150  2
                         root_1 = (Object)adaptor.becomeRoot(
 21151  
                         stream_TIMEZONE.nextNode()
 21152  
                         , root_1);
 21153  
 
 21154  2
                         adaptor.addChild(root_1, stream_expression.nextTree());
 21155  
 
 21156  2
                         adaptor.addChild(root_0, root_1);
 21157  
                         }
 21158  
 
 21159  
                     }
 21160  
 
 21161  
 
 21162  2
                     retval.tree = root_0;
 21163  
 
 21164  
                     }
 21165  2
                     break;
 21166  
                 case 34 :
 21167  
                     // com\\googlecode\\sparkleg\\Sparql.g:578:7: TZ OPEN_BRACE expression CLOSE_BRACE
 21168  
                     {
 21169  2
                     TZ527=(Token)match(input,TZ,FOLLOW_TZ_in_builtInCall5794);  
 21170  2
                     stream_TZ.add(TZ527);
 21171  
 
 21172  
 
 21173  2
                     OPEN_BRACE528=(Token)match(input,OPEN_BRACE,FOLLOW_OPEN_BRACE_in_builtInCall5796);  
 21174  2
                     stream_OPEN_BRACE.add(OPEN_BRACE528);
 21175  
 
 21176  
 
 21177  2
                     pushFollow(FOLLOW_expression_in_builtInCall5798);
 21178  2
                     expression529=expression();
 21179  
 
 21180  2
                     state._fsp--;
 21181  
 
 21182  2
                     stream_expression.add(expression529.getTree());
 21183  
 
 21184  2
                     CLOSE_BRACE530=(Token)match(input,CLOSE_BRACE,FOLLOW_CLOSE_BRACE_in_builtInCall5800);  
 21185  2
                     stream_CLOSE_BRACE.add(CLOSE_BRACE530);
 21186  
 
 21187  
 
 21188  
                     // AST REWRITE
 21189  
                     // elements: expression, TZ
 21190  
                     // token labels: 
 21191  
                     // rule labels: retval
 21192  
                     // token list labels: 
 21193  
                     // rule list labels: 
 21194  
                     // wildcard labels: 
 21195  2
                     retval.tree = root_0;
 21196  2
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 21197  
 
 21198  2
                     root_0 = (Object)adaptor.nil();
 21199  
                     // 578:44: -> ^( TZ expression )
 21200  
                     {
 21201  
                         // com\\googlecode\\sparkleg\\Sparql.g:578:47: ^( TZ expression )
 21202  
                         {
 21203  2
                         Object root_1 = (Object)adaptor.nil();
 21204  2
                         root_1 = (Object)adaptor.becomeRoot(
 21205  
                         stream_TZ.nextNode()
 21206  
                         , root_1);
 21207  
 
 21208  2
                         adaptor.addChild(root_1, stream_expression.nextTree());
 21209  
 
 21210  2
                         adaptor.addChild(root_0, root_1);
 21211  
                         }
 21212  
 
 21213  
                     }
 21214  
 
 21215  
 
 21216  2
                     retval.tree = root_0;
 21217  
 
 21218  
                     }
 21219  2
                     break;
 21220  
                 case 35 :
 21221  
                     // com\\googlecode\\sparkleg\\Sparql.g:579:7: NOW nil
 21222  
                     {
 21223  2
                     NOW531=(Token)match(input,NOW,FOLLOW_NOW_in_builtInCall5816);  
 21224  2
                     stream_NOW.add(NOW531);
 21225  
 
 21226  
 
 21227  2
                     pushFollow(FOLLOW_nil_in_builtInCall5818);
 21228  2
                     nil532=nil();
 21229  
 
 21230  2
                     state._fsp--;
 21231  
 
 21232  2
                     stream_nil.add(nil532.getTree());
 21233  
 
 21234  
                     // AST REWRITE
 21235  
                     // elements: NOW
 21236  
                     // token labels: 
 21237  
                     // rule labels: retval
 21238  
                     // token list labels: 
 21239  
                     // rule list labels: 
 21240  
                     // wildcard labels: 
 21241  2
                     retval.tree = root_0;
 21242  2
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 21243  
 
 21244  2
                     root_0 = (Object)adaptor.nil();
 21245  
                     // 579:15: -> NOW
 21246  
                     {
 21247  2
                         adaptor.addChild(root_0, 
 21248  
                         stream_NOW.nextNode()
 21249  
                         );
 21250  
 
 21251  
                     }
 21252  
 
 21253  
 
 21254  2
                     retval.tree = root_0;
 21255  
 
 21256  
                     }
 21257  2
                     break;
 21258  
                 case 36 :
 21259  
                     // com\\googlecode\\sparkleg\\Sparql.g:580:7: MD5 OPEN_BRACE expression CLOSE_BRACE
 21260  
                     {
 21261  4
                     MD5533=(Token)match(input,MD5,FOLLOW_MD5_in_builtInCall5830);  
 21262  4
                     stream_MD5.add(MD5533);
 21263  
 
 21264  
 
 21265  4
                     OPEN_BRACE534=(Token)match(input,OPEN_BRACE,FOLLOW_OPEN_BRACE_in_builtInCall5832);  
 21266  4
                     stream_OPEN_BRACE.add(OPEN_BRACE534);
 21267  
 
 21268  
 
 21269  4
                     pushFollow(FOLLOW_expression_in_builtInCall5834);
 21270  4
                     expression535=expression();
 21271  
 
 21272  4
                     state._fsp--;
 21273  
 
 21274  4
                     stream_expression.add(expression535.getTree());
 21275  
 
 21276  4
                     CLOSE_BRACE536=(Token)match(input,CLOSE_BRACE,FOLLOW_CLOSE_BRACE_in_builtInCall5836);  
 21277  4
                     stream_CLOSE_BRACE.add(CLOSE_BRACE536);
 21278  
 
 21279  
 
 21280  
                     // AST REWRITE
 21281  
                     // elements: MD5, expression
 21282  
                     // token labels: 
 21283  
                     // rule labels: retval
 21284  
                     // token list labels: 
 21285  
                     // rule list labels: 
 21286  
                     // wildcard labels: 
 21287  4
                     retval.tree = root_0;
 21288  4
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 21289  
 
 21290  4
                     root_0 = (Object)adaptor.nil();
 21291  
                     // 580:45: -> ^( MD5 expression )
 21292  
                     {
 21293  
                         // com\\googlecode\\sparkleg\\Sparql.g:580:48: ^( MD5 expression )
 21294  
                         {
 21295  4
                         Object root_1 = (Object)adaptor.nil();
 21296  4
                         root_1 = (Object)adaptor.becomeRoot(
 21297  
                         stream_MD5.nextNode()
 21298  
                         , root_1);
 21299  
 
 21300  4
                         adaptor.addChild(root_1, stream_expression.nextTree());
 21301  
 
 21302  4
                         adaptor.addChild(root_0, root_1);
 21303  
                         }
 21304  
 
 21305  
                     }
 21306  
 
 21307  
 
 21308  4
                     retval.tree = root_0;
 21309  
 
 21310  
                     }
 21311  4
                     break;
 21312  
                 case 37 :
 21313  
                     // com\\googlecode\\sparkleg\\Sparql.g:581:7: SHA1 OPEN_BRACE expression CLOSE_BRACE
 21314  
                     {
 21315  4
                     SHA1537=(Token)match(input,SHA1,FOLLOW_SHA1_in_builtInCall5852);  
 21316  4
                     stream_SHA1.add(SHA1537);
 21317  
 
 21318  
 
 21319  4
                     OPEN_BRACE538=(Token)match(input,OPEN_BRACE,FOLLOW_OPEN_BRACE_in_builtInCall5854);  
 21320  4
                     stream_OPEN_BRACE.add(OPEN_BRACE538);
 21321  
 
 21322  
 
 21323  4
                     pushFollow(FOLLOW_expression_in_builtInCall5856);
 21324  4
                     expression539=expression();
 21325  
 
 21326  4
                     state._fsp--;
 21327  
 
 21328  4
                     stream_expression.add(expression539.getTree());
 21329  
 
 21330  4
                     CLOSE_BRACE540=(Token)match(input,CLOSE_BRACE,FOLLOW_CLOSE_BRACE_in_builtInCall5858);  
 21331  4
                     stream_CLOSE_BRACE.add(CLOSE_BRACE540);
 21332  
 
 21333  
 
 21334  
                     // AST REWRITE
 21335  
                     // elements: expression, SHA1
 21336  
                     // token labels: 
 21337  
                     // rule labels: retval
 21338  
                     // token list labels: 
 21339  
                     // rule list labels: 
 21340  
                     // wildcard labels: 
 21341  4
                     retval.tree = root_0;
 21342  4
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 21343  
 
 21344  4
                     root_0 = (Object)adaptor.nil();
 21345  
                     // 581:46: -> ^( SHA1 expression )
 21346  
                     {
 21347  
                         // com\\googlecode\\sparkleg\\Sparql.g:581:49: ^( SHA1 expression )
 21348  
                         {
 21349  4
                         Object root_1 = (Object)adaptor.nil();
 21350  4
                         root_1 = (Object)adaptor.becomeRoot(
 21351  
                         stream_SHA1.nextNode()
 21352  
                         , root_1);
 21353  
 
 21354  4
                         adaptor.addChild(root_1, stream_expression.nextTree());
 21355  
 
 21356  4
                         adaptor.addChild(root_0, root_1);
 21357  
                         }
 21358  
 
 21359  
                     }
 21360  
 
 21361  
 
 21362  4
                     retval.tree = root_0;
 21363  
 
 21364  
                     }
 21365  4
                     break;
 21366  
                 case 38 :
 21367  
                     // com\\googlecode\\sparkleg\\Sparql.g:582:7: SHA224 OPEN_BRACE expression CLOSE_BRACE
 21368  
                     {
 21369  0
                     SHA224541=(Token)match(input,SHA224,FOLLOW_SHA224_in_builtInCall5874);  
 21370  0
                     stream_SHA224.add(SHA224541);
 21371  
 
 21372  
 
 21373  0
                     OPEN_BRACE542=(Token)match(input,OPEN_BRACE,FOLLOW_OPEN_BRACE_in_builtInCall5876);  
 21374  0
                     stream_OPEN_BRACE.add(OPEN_BRACE542);
 21375  
 
 21376  
 
 21377  0
                     pushFollow(FOLLOW_expression_in_builtInCall5878);
 21378  0
                     expression543=expression();
 21379  
 
 21380  0
                     state._fsp--;
 21381  
 
 21382  0
                     stream_expression.add(expression543.getTree());
 21383  
 
 21384  0
                     CLOSE_BRACE544=(Token)match(input,CLOSE_BRACE,FOLLOW_CLOSE_BRACE_in_builtInCall5880);  
 21385  0
                     stream_CLOSE_BRACE.add(CLOSE_BRACE544);
 21386  
 
 21387  
 
 21388  
                     // AST REWRITE
 21389  
                     // elements: expression, SHA224
 21390  
                     // token labels: 
 21391  
                     // rule labels: retval
 21392  
                     // token list labels: 
 21393  
                     // rule list labels: 
 21394  
                     // wildcard labels: 
 21395  0
                     retval.tree = root_0;
 21396  0
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 21397  
 
 21398  0
                     root_0 = (Object)adaptor.nil();
 21399  
                     // 582:48: -> ^( SHA224 expression )
 21400  
                     {
 21401  
                         // com\\googlecode\\sparkleg\\Sparql.g:582:51: ^( SHA224 expression )
 21402  
                         {
 21403  0
                         Object root_1 = (Object)adaptor.nil();
 21404  0
                         root_1 = (Object)adaptor.becomeRoot(
 21405  
                         stream_SHA224.nextNode()
 21406  
                         , root_1);
 21407  
 
 21408  0
                         adaptor.addChild(root_1, stream_expression.nextTree());
 21409  
 
 21410  0
                         adaptor.addChild(root_0, root_1);
 21411  
                         }
 21412  
 
 21413  
                     }
 21414  
 
 21415  
 
 21416  0
                     retval.tree = root_0;
 21417  
 
 21418  
                     }
 21419  0
                     break;
 21420  
                 case 39 :
 21421  
                     // com\\googlecode\\sparkleg\\Sparql.g:583:7: SHA256 OPEN_BRACE expression CLOSE_BRACE
 21422  
                     {
 21423  4
                     SHA256545=(Token)match(input,SHA256,FOLLOW_SHA256_in_builtInCall5896);  
 21424  4
                     stream_SHA256.add(SHA256545);
 21425  
 
 21426  
 
 21427  4
                     OPEN_BRACE546=(Token)match(input,OPEN_BRACE,FOLLOW_OPEN_BRACE_in_builtInCall5898);  
 21428  4
                     stream_OPEN_BRACE.add(OPEN_BRACE546);
 21429  
 
 21430  
 
 21431  4
                     pushFollow(FOLLOW_expression_in_builtInCall5900);
 21432  4
                     expression547=expression();
 21433  
 
 21434  4
                     state._fsp--;
 21435  
 
 21436  4
                     stream_expression.add(expression547.getTree());
 21437  
 
 21438  4
                     CLOSE_BRACE548=(Token)match(input,CLOSE_BRACE,FOLLOW_CLOSE_BRACE_in_builtInCall5902);  
 21439  4
                     stream_CLOSE_BRACE.add(CLOSE_BRACE548);
 21440  
 
 21441  
 
 21442  
                     // AST REWRITE
 21443  
                     // elements: SHA256, expression
 21444  
                     // token labels: 
 21445  
                     // rule labels: retval
 21446  
                     // token list labels: 
 21447  
                     // rule list labels: 
 21448  
                     // wildcard labels: 
 21449  4
                     retval.tree = root_0;
 21450  4
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 21451  
 
 21452  4
                     root_0 = (Object)adaptor.nil();
 21453  
                     // 583:48: -> ^( SHA256 expression )
 21454  
                     {
 21455  
                         // com\\googlecode\\sparkleg\\Sparql.g:583:51: ^( SHA256 expression )
 21456  
                         {
 21457  4
                         Object root_1 = (Object)adaptor.nil();
 21458  4
                         root_1 = (Object)adaptor.becomeRoot(
 21459  
                         stream_SHA256.nextNode()
 21460  
                         , root_1);
 21461  
 
 21462  4
                         adaptor.addChild(root_1, stream_expression.nextTree());
 21463  
 
 21464  4
                         adaptor.addChild(root_0, root_1);
 21465  
                         }
 21466  
 
 21467  
                     }
 21468  
 
 21469  
 
 21470  4
                     retval.tree = root_0;
 21471  
 
 21472  
                     }
 21473  4
                     break;
 21474  
                 case 40 :
 21475  
                     // com\\googlecode\\sparkleg\\Sparql.g:584:7: SHA384 OPEN_BRACE expression CLOSE_BRACE
 21476  
                     {
 21477  4
                     SHA384549=(Token)match(input,SHA384,FOLLOW_SHA384_in_builtInCall5918);  
 21478  4
                     stream_SHA384.add(SHA384549);
 21479  
 
 21480  
 
 21481  4
                     OPEN_BRACE550=(Token)match(input,OPEN_BRACE,FOLLOW_OPEN_BRACE_in_builtInCall5920);  
 21482  4
                     stream_OPEN_BRACE.add(OPEN_BRACE550);
 21483  
 
 21484  
 
 21485  4
                     pushFollow(FOLLOW_expression_in_builtInCall5922);
 21486  4
                     expression551=expression();
 21487  
 
 21488  4
                     state._fsp--;
 21489  
 
 21490  4
                     stream_expression.add(expression551.getTree());
 21491  
 
 21492  4
                     CLOSE_BRACE552=(Token)match(input,CLOSE_BRACE,FOLLOW_CLOSE_BRACE_in_builtInCall5924);  
 21493  4
                     stream_CLOSE_BRACE.add(CLOSE_BRACE552);
 21494  
 
 21495  
 
 21496  
                     // AST REWRITE
 21497  
                     // elements: SHA384, expression
 21498  
                     // token labels: 
 21499  
                     // rule labels: retval
 21500  
                     // token list labels: 
 21501  
                     // rule list labels: 
 21502  
                     // wildcard labels: 
 21503  4
                     retval.tree = root_0;
 21504  4
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 21505  
 
 21506  4
                     root_0 = (Object)adaptor.nil();
 21507  
                     // 584:48: -> ^( SHA384 expression )
 21508  
                     {
 21509  
                         // com\\googlecode\\sparkleg\\Sparql.g:584:51: ^( SHA384 expression )
 21510  
                         {
 21511  4
                         Object root_1 = (Object)adaptor.nil();
 21512  4
                         root_1 = (Object)adaptor.becomeRoot(
 21513  
                         stream_SHA384.nextNode()
 21514  
                         , root_1);
 21515  
 
 21516  4
                         adaptor.addChild(root_1, stream_expression.nextTree());
 21517  
 
 21518  4
                         adaptor.addChild(root_0, root_1);
 21519  
                         }
 21520  
 
 21521  
                     }
 21522  
 
 21523  
 
 21524  4
                     retval.tree = root_0;
 21525  
 
 21526  
                     }
 21527  4
                     break;
 21528  
                 case 41 :
 21529  
                     // com\\googlecode\\sparkleg\\Sparql.g:585:7: SHA512 OPEN_BRACE expression CLOSE_BRACE
 21530  
                     {
 21531  4
                     SHA512553=(Token)match(input,SHA512,FOLLOW_SHA512_in_builtInCall5940);  
 21532  4
                     stream_SHA512.add(SHA512553);
 21533  
 
 21534  
 
 21535  4
                     OPEN_BRACE554=(Token)match(input,OPEN_BRACE,FOLLOW_OPEN_BRACE_in_builtInCall5942);  
 21536  4
                     stream_OPEN_BRACE.add(OPEN_BRACE554);
 21537  
 
 21538  
 
 21539  4
                     pushFollow(FOLLOW_expression_in_builtInCall5944);
 21540  4
                     expression555=expression();
 21541  
 
 21542  4
                     state._fsp--;
 21543  
 
 21544  4
                     stream_expression.add(expression555.getTree());
 21545  
 
 21546  4
                     CLOSE_BRACE556=(Token)match(input,CLOSE_BRACE,FOLLOW_CLOSE_BRACE_in_builtInCall5946);  
 21547  4
                     stream_CLOSE_BRACE.add(CLOSE_BRACE556);
 21548  
 
 21549  
 
 21550  
                     // AST REWRITE
 21551  
                     // elements: expression, SHA512
 21552  
                     // token labels: 
 21553  
                     // rule labels: retval
 21554  
                     // token list labels: 
 21555  
                     // rule list labels: 
 21556  
                     // wildcard labels: 
 21557  4
                     retval.tree = root_0;
 21558  4
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 21559  
 
 21560  4
                     root_0 = (Object)adaptor.nil();
 21561  
                     // 585:48: -> ^( SHA512 expression )
 21562  
                     {
 21563  
                         // com\\googlecode\\sparkleg\\Sparql.g:585:51: ^( SHA512 expression )
 21564  
                         {
 21565  4
                         Object root_1 = (Object)adaptor.nil();
 21566  4
                         root_1 = (Object)adaptor.becomeRoot(
 21567  
                         stream_SHA512.nextNode()
 21568  
                         , root_1);
 21569  
 
 21570  4
                         adaptor.addChild(root_1, stream_expression.nextTree());
 21571  
 
 21572  4
                         adaptor.addChild(root_0, root_1);
 21573  
                         }
 21574  
 
 21575  
                     }
 21576  
 
 21577  
 
 21578  4
                     retval.tree = root_0;
 21579  
 
 21580  
                     }
 21581  4
                     break;
 21582  
                 case 42 :
 21583  
                     // com\\googlecode\\sparkleg\\Sparql.g:586:7: COALESCE expressionList
 21584  
                     {
 21585  12
                     COALESCE557=(Token)match(input,COALESCE,FOLLOW_COALESCE_in_builtInCall5962);  
 21586  12
                     stream_COALESCE.add(COALESCE557);
 21587  
 
 21588  
 
 21589  12
                     pushFollow(FOLLOW_expressionList_in_builtInCall5964);
 21590  12
                     expressionList558=expressionList();
 21591  
 
 21592  12
                     state._fsp--;
 21593  
 
 21594  12
                     stream_expressionList.add(expressionList558.getTree());
 21595  
 
 21596  
                     // AST REWRITE
 21597  
                     // elements: expressionList, COALESCE
 21598  
                     // token labels: 
 21599  
                     // rule labels: retval
 21600  
                     // token list labels: 
 21601  
                     // rule list labels: 
 21602  
                     // wildcard labels: 
 21603  12
                     retval.tree = root_0;
 21604  12
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 21605  
 
 21606  12
                     root_0 = (Object)adaptor.nil();
 21607  
                     // 586:31: -> ^( COALESCE expressionList )
 21608  
                     {
 21609  
                         // com\\googlecode\\sparkleg\\Sparql.g:586:34: ^( COALESCE expressionList )
 21610  
                         {
 21611  12
                         Object root_1 = (Object)adaptor.nil();
 21612  12
                         root_1 = (Object)adaptor.becomeRoot(
 21613  
                         stream_COALESCE.nextNode()
 21614  
                         , root_1);
 21615  
 
 21616  12
                         adaptor.addChild(root_1, stream_expressionList.nextTree());
 21617  
 
 21618  12
                         adaptor.addChild(root_0, root_1);
 21619  
                         }
 21620  
 
 21621  
                     }
 21622  
 
 21623  
 
 21624  12
                     retval.tree = root_0;
 21625  
 
 21626  
                     }
 21627  12
                     break;
 21628  
                 case 43 :
 21629  
                     // com\\googlecode\\sparkleg\\Sparql.g:587:7: IF OPEN_BRACE e1= expression COMMA e2= expression COMMA e3= expression CLOSE_BRACE
 21630  
                     {
 21631  6
                     IF559=(Token)match(input,IF,FOLLOW_IF_in_builtInCall5980);  
 21632  6
                     stream_IF.add(IF559);
 21633  
 
 21634  
 
 21635  6
                     OPEN_BRACE560=(Token)match(input,OPEN_BRACE,FOLLOW_OPEN_BRACE_in_builtInCall5982);  
 21636  6
                     stream_OPEN_BRACE.add(OPEN_BRACE560);
 21637  
 
 21638  
 
 21639  6
                     pushFollow(FOLLOW_expression_in_builtInCall5986);
 21640  6
                     e1=expression();
 21641  
 
 21642  6
                     state._fsp--;
 21643  
 
 21644  6
                     stream_expression.add(e1.getTree());
 21645  
 
 21646  6
                     COMMA561=(Token)match(input,COMMA,FOLLOW_COMMA_in_builtInCall5988);  
 21647  6
                     stream_COMMA.add(COMMA561);
 21648  
 
 21649  
 
 21650  6
                     pushFollow(FOLLOW_expression_in_builtInCall5992);
 21651  6
                     e2=expression();
 21652  
 
 21653  6
                     state._fsp--;
 21654  
 
 21655  6
                     stream_expression.add(e2.getTree());
 21656  
 
 21657  6
                     COMMA562=(Token)match(input,COMMA,FOLLOW_COMMA_in_builtInCall5994);  
 21658  6
                     stream_COMMA.add(COMMA562);
 21659  
 
 21660  
 
 21661  6
                     pushFollow(FOLLOW_expression_in_builtInCall5998);
 21662  6
                     e3=expression();
 21663  
 
 21664  6
                     state._fsp--;
 21665  
 
 21666  6
                     stream_expression.add(e3.getTree());
 21667  
 
 21668  6
                     CLOSE_BRACE563=(Token)match(input,CLOSE_BRACE,FOLLOW_CLOSE_BRACE_in_builtInCall6000);  
 21669  6
                     stream_CLOSE_BRACE.add(CLOSE_BRACE563);
 21670  
 
 21671  
 
 21672  
                     // AST REWRITE
 21673  
                     // elements: e2, e1, e3, IF
 21674  
                     // token labels: 
 21675  
                     // rule labels: e3, retval, e1, e2
 21676  
                     // token list labels: 
 21677  
                     // rule list labels: 
 21678  
                     // wildcard labels: 
 21679  6
                     retval.tree = root_0;
 21680  6
                     RewriteRuleSubtreeStream stream_e3=new RewriteRuleSubtreeStream(adaptor,"rule e3",e3!=null?e3.tree:null);
 21681  6
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 21682  6
                     RewriteRuleSubtreeStream stream_e1=new RewriteRuleSubtreeStream(adaptor,"rule e1",e1!=null?e1.tree:null);
 21683  6
                     RewriteRuleSubtreeStream stream_e2=new RewriteRuleSubtreeStream(adaptor,"rule e2",e2!=null?e2.tree:null);
 21684  
 
 21685  6
                     root_0 = (Object)adaptor.nil();
 21686  
                     // 587:87: -> ^( IF $e1 $e2 $e3)
 21687  
                     {
 21688  
                         // com\\googlecode\\sparkleg\\Sparql.g:587:90: ^( IF $e1 $e2 $e3)
 21689  
                         {
 21690  6
                         Object root_1 = (Object)adaptor.nil();
 21691  6
                         root_1 = (Object)adaptor.becomeRoot(
 21692  
                         stream_IF.nextNode()
 21693  
                         , root_1);
 21694  
 
 21695  6
                         adaptor.addChild(root_1, stream_e1.nextTree());
 21696  
 
 21697  6
                         adaptor.addChild(root_1, stream_e2.nextTree());
 21698  
 
 21699  6
                         adaptor.addChild(root_1, stream_e3.nextTree());
 21700  
 
 21701  6
                         adaptor.addChild(root_0, root_1);
 21702  
                         }
 21703  
 
 21704  
                     }
 21705  
 
 21706  
 
 21707  6
                     retval.tree = root_0;
 21708  
 
 21709  
                     }
 21710  6
                     break;
 21711  
                 case 44 :
 21712  
                     // com\\googlecode\\sparkleg\\Sparql.g:588:7: STRLANG OPEN_BRACE expression COMMA expression CLOSE_BRACE
 21713  
                     {
 21714  6
                     STRLANG564=(Token)match(input,STRLANG,FOLLOW_STRLANG_in_builtInCall6023);  
 21715  6
                     stream_STRLANG.add(STRLANG564);
 21716  
 
 21717  
 
 21718  6
                     OPEN_BRACE565=(Token)match(input,OPEN_BRACE,FOLLOW_OPEN_BRACE_in_builtInCall6025);  
 21719  6
                     stream_OPEN_BRACE.add(OPEN_BRACE565);
 21720  
 
 21721  
 
 21722  6
                     pushFollow(FOLLOW_expression_in_builtInCall6027);
 21723  6
                     expression566=expression();
 21724  
 
 21725  6
                     state._fsp--;
 21726  
 
 21727  6
                     stream_expression.add(expression566.getTree());
 21728  
 
 21729  6
                     COMMA567=(Token)match(input,COMMA,FOLLOW_COMMA_in_builtInCall6029);  
 21730  6
                     stream_COMMA.add(COMMA567);
 21731  
 
 21732  
 
 21733  6
                     pushFollow(FOLLOW_expression_in_builtInCall6031);
 21734  6
                     expression568=expression();
 21735  
 
 21736  6
                     state._fsp--;
 21737  
 
 21738  6
                     stream_expression.add(expression568.getTree());
 21739  
 
 21740  6
                     CLOSE_BRACE569=(Token)match(input,CLOSE_BRACE,FOLLOW_CLOSE_BRACE_in_builtInCall6033);  
 21741  6
                     stream_CLOSE_BRACE.add(CLOSE_BRACE569);
 21742  
 
 21743  
 
 21744  
                     // AST REWRITE
 21745  
                     // elements: STRLANG, expression, expression
 21746  
                     // token labels: 
 21747  
                     // rule labels: retval
 21748  
                     // token list labels: 
 21749  
                     // rule list labels: 
 21750  
                     // wildcard labels: 
 21751  6
                     retval.tree = root_0;
 21752  6
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 21753  
 
 21754  6
                     root_0 = (Object)adaptor.nil();
 21755  
                     // 588:66: -> ^( STRLANG expression expression )
 21756  
                     {
 21757  
                         // com\\googlecode\\sparkleg\\Sparql.g:588:69: ^( STRLANG expression expression )
 21758  
                         {
 21759  6
                         Object root_1 = (Object)adaptor.nil();
 21760  6
                         root_1 = (Object)adaptor.becomeRoot(
 21761  
                         stream_STRLANG.nextNode()
 21762  
                         , root_1);
 21763  
 
 21764  6
                         adaptor.addChild(root_1, stream_expression.nextTree());
 21765  
 
 21766  6
                         adaptor.addChild(root_1, stream_expression.nextTree());
 21767  
 
 21768  6
                         adaptor.addChild(root_0, root_1);
 21769  
                         }
 21770  
 
 21771  
                     }
 21772  
 
 21773  
 
 21774  6
                     retval.tree = root_0;
 21775  
 
 21776  
                     }
 21777  6
                     break;
 21778  
                 case 45 :
 21779  
                     // com\\googlecode\\sparkleg\\Sparql.g:589:7: STRDT OPEN_BRACE expression COMMA expression CLOSE_BRACE
 21780  
                     {
 21781  6
                     STRDT570=(Token)match(input,STRDT,FOLLOW_STRDT_in_builtInCall6051);  
 21782  6
                     stream_STRDT.add(STRDT570);
 21783  
 
 21784  
 
 21785  6
                     OPEN_BRACE571=(Token)match(input,OPEN_BRACE,FOLLOW_OPEN_BRACE_in_builtInCall6053);  
 21786  6
                     stream_OPEN_BRACE.add(OPEN_BRACE571);
 21787  
 
 21788  
 
 21789  6
                     pushFollow(FOLLOW_expression_in_builtInCall6055);
 21790  6
                     expression572=expression();
 21791  
 
 21792  6
                     state._fsp--;
 21793  
 
 21794  6
                     stream_expression.add(expression572.getTree());
 21795  
 
 21796  6
                     COMMA573=(Token)match(input,COMMA,FOLLOW_COMMA_in_builtInCall6057);  
 21797  6
                     stream_COMMA.add(COMMA573);
 21798  
 
 21799  
 
 21800  6
                     pushFollow(FOLLOW_expression_in_builtInCall6059);
 21801  6
                     expression574=expression();
 21802  
 
 21803  6
                     state._fsp--;
 21804  
 
 21805  6
                     stream_expression.add(expression574.getTree());
 21806  
 
 21807  6
                     CLOSE_BRACE575=(Token)match(input,CLOSE_BRACE,FOLLOW_CLOSE_BRACE_in_builtInCall6061);  
 21808  6
                     stream_CLOSE_BRACE.add(CLOSE_BRACE575);
 21809  
 
 21810  
 
 21811  
                     // AST REWRITE
 21812  
                     // elements: expression, STRDT, expression
 21813  
                     // token labels: 
 21814  
                     // rule labels: retval
 21815  
                     // token list labels: 
 21816  
                     // rule list labels: 
 21817  
                     // wildcard labels: 
 21818  6
                     retval.tree = root_0;
 21819  6
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 21820  
 
 21821  6
                     root_0 = (Object)adaptor.nil();
 21822  
                     // 589:64: -> ^( STRDT expression expression )
 21823  
                     {
 21824  
                         // com\\googlecode\\sparkleg\\Sparql.g:589:67: ^( STRDT expression expression )
 21825  
                         {
 21826  6
                         Object root_1 = (Object)adaptor.nil();
 21827  6
                         root_1 = (Object)adaptor.becomeRoot(
 21828  
                         stream_STRDT.nextNode()
 21829  
                         , root_1);
 21830  
 
 21831  6
                         adaptor.addChild(root_1, stream_expression.nextTree());
 21832  
 
 21833  6
                         adaptor.addChild(root_1, stream_expression.nextTree());
 21834  
 
 21835  6
                         adaptor.addChild(root_0, root_1);
 21836  
                         }
 21837  
 
 21838  
                     }
 21839  
 
 21840  
 
 21841  6
                     retval.tree = root_0;
 21842  
 
 21843  
                     }
 21844  6
                     break;
 21845  
                 case 46 :
 21846  
                     // com\\googlecode\\sparkleg\\Sparql.g:590:7: SAMETERM OPEN_BRACE expression COMMA expression CLOSE_BRACE
 21847  
                     {
 21848  30
                     SAMETERM576=(Token)match(input,SAMETERM,FOLLOW_SAMETERM_in_builtInCall6079);  
 21849  30
                     stream_SAMETERM.add(SAMETERM576);
 21850  
 
 21851  
 
 21852  30
                     OPEN_BRACE577=(Token)match(input,OPEN_BRACE,FOLLOW_OPEN_BRACE_in_builtInCall6081);  
 21853  30
                     stream_OPEN_BRACE.add(OPEN_BRACE577);
 21854  
 
 21855  
 
 21856  30
                     pushFollow(FOLLOW_expression_in_builtInCall6083);
 21857  30
                     expression578=expression();
 21858  
 
 21859  30
                     state._fsp--;
 21860  
 
 21861  30
                     stream_expression.add(expression578.getTree());
 21862  
 
 21863  30
                     COMMA579=(Token)match(input,COMMA,FOLLOW_COMMA_in_builtInCall6085);  
 21864  30
                     stream_COMMA.add(COMMA579);
 21865  
 
 21866  
 
 21867  30
                     pushFollow(FOLLOW_expression_in_builtInCall6087);
 21868  30
                     expression580=expression();
 21869  
 
 21870  30
                     state._fsp--;
 21871  
 
 21872  30
                     stream_expression.add(expression580.getTree());
 21873  
 
 21874  30
                     CLOSE_BRACE581=(Token)match(input,CLOSE_BRACE,FOLLOW_CLOSE_BRACE_in_builtInCall6089);  
 21875  30
                     stream_CLOSE_BRACE.add(CLOSE_BRACE581);
 21876  
 
 21877  
 
 21878  
                     // AST REWRITE
 21879  
                     // elements: expression, expression, SAMETERM
 21880  
                     // token labels: 
 21881  
                     // rule labels: retval
 21882  
                     // token list labels: 
 21883  
                     // rule list labels: 
 21884  
                     // wildcard labels: 
 21885  30
                     retval.tree = root_0;
 21886  30
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 21887  
 
 21888  30
                     root_0 = (Object)adaptor.nil();
 21889  
                     // 590:67: -> ^( SAMETERM expression expression )
 21890  
                     {
 21891  
                         // com\\googlecode\\sparkleg\\Sparql.g:590:70: ^( SAMETERM expression expression )
 21892  
                         {
 21893  30
                         Object root_1 = (Object)adaptor.nil();
 21894  30
                         root_1 = (Object)adaptor.becomeRoot(
 21895  
                         stream_SAMETERM.nextNode()
 21896  
                         , root_1);
 21897  
 
 21898  30
                         adaptor.addChild(root_1, stream_expression.nextTree());
 21899  
 
 21900  30
                         adaptor.addChild(root_1, stream_expression.nextTree());
 21901  
 
 21902  30
                         adaptor.addChild(root_0, root_1);
 21903  
                         }
 21904  
 
 21905  
                     }
 21906  
 
 21907  
 
 21908  30
                     retval.tree = root_0;
 21909  
 
 21910  
                     }
 21911  30
                     break;
 21912  
                 case 47 :
 21913  
                     // com\\googlecode\\sparkleg\\Sparql.g:591:7: ISIRI OPEN_BRACE expression CLOSE_BRACE
 21914  
                     {
 21915  8
                     ISIRI582=(Token)match(input,ISIRI,FOLLOW_ISIRI_in_builtInCall6107);  
 21916  8
                     stream_ISIRI.add(ISIRI582);
 21917  
 
 21918  
 
 21919  8
                     OPEN_BRACE583=(Token)match(input,OPEN_BRACE,FOLLOW_OPEN_BRACE_in_builtInCall6109);  
 21920  8
                     stream_OPEN_BRACE.add(OPEN_BRACE583);
 21921  
 
 21922  
 
 21923  8
                     pushFollow(FOLLOW_expression_in_builtInCall6111);
 21924  8
                     expression584=expression();
 21925  
 
 21926  8
                     state._fsp--;
 21927  
 
 21928  8
                     stream_expression.add(expression584.getTree());
 21929  
 
 21930  8
                     CLOSE_BRACE585=(Token)match(input,CLOSE_BRACE,FOLLOW_CLOSE_BRACE_in_builtInCall6113);  
 21931  8
                     stream_CLOSE_BRACE.add(CLOSE_BRACE585);
 21932  
 
 21933  
 
 21934  
                     // AST REWRITE
 21935  
                     // elements: expression, ISIRI
 21936  
                     // token labels: 
 21937  
                     // rule labels: retval
 21938  
                     // token list labels: 
 21939  
                     // rule list labels: 
 21940  
                     // wildcard labels: 
 21941  8
                     retval.tree = root_0;
 21942  8
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 21943  
 
 21944  8
                     root_0 = (Object)adaptor.nil();
 21945  
                     // 591:47: -> ^( ISIRI expression )
 21946  
                     {
 21947  
                         // com\\googlecode\\sparkleg\\Sparql.g:591:50: ^( ISIRI expression )
 21948  
                         {
 21949  8
                         Object root_1 = (Object)adaptor.nil();
 21950  8
                         root_1 = (Object)adaptor.becomeRoot(
 21951  
                         stream_ISIRI.nextNode()
 21952  
                         , root_1);
 21953  
 
 21954  8
                         adaptor.addChild(root_1, stream_expression.nextTree());
 21955  
 
 21956  8
                         adaptor.addChild(root_0, root_1);
 21957  
                         }
 21958  
 
 21959  
                     }
 21960  
 
 21961  
 
 21962  8
                     retval.tree = root_0;
 21963  
 
 21964  
                     }
 21965  8
                     break;
 21966  
                 case 48 :
 21967  
                     // com\\googlecode\\sparkleg\\Sparql.g:592:7: ISURI OPEN_BRACE expression CLOSE_BRACE
 21968  
                     {
 21969  2
                     ISURI586=(Token)match(input,ISURI,FOLLOW_ISURI_in_builtInCall6129);  
 21970  2
                     stream_ISURI.add(ISURI586);
 21971  
 
 21972  
 
 21973  2
                     OPEN_BRACE587=(Token)match(input,OPEN_BRACE,FOLLOW_OPEN_BRACE_in_builtInCall6131);  
 21974  2
                     stream_OPEN_BRACE.add(OPEN_BRACE587);
 21975  
 
 21976  
 
 21977  2
                     pushFollow(FOLLOW_expression_in_builtInCall6133);
 21978  2
                     expression588=expression();
 21979  
 
 21980  2
                     state._fsp--;
 21981  
 
 21982  2
                     stream_expression.add(expression588.getTree());
 21983  
 
 21984  2
                     CLOSE_BRACE589=(Token)match(input,CLOSE_BRACE,FOLLOW_CLOSE_BRACE_in_builtInCall6135);  
 21985  2
                     stream_CLOSE_BRACE.add(CLOSE_BRACE589);
 21986  
 
 21987  
 
 21988  
                     // AST REWRITE
 21989  
                     // elements: expression, ISURI
 21990  
                     // token labels: 
 21991  
                     // rule labels: retval
 21992  
                     // token list labels: 
 21993  
                     // rule list labels: 
 21994  
                     // wildcard labels: 
 21995  2
                     retval.tree = root_0;
 21996  2
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 21997  
 
 21998  2
                     root_0 = (Object)adaptor.nil();
 21999  
                     // 592:47: -> ^( ISURI expression )
 22000  
                     {
 22001  
                         // com\\googlecode\\sparkleg\\Sparql.g:592:50: ^( ISURI expression )
 22002  
                         {
 22003  2
                         Object root_1 = (Object)adaptor.nil();
 22004  2
                         root_1 = (Object)adaptor.becomeRoot(
 22005  
                         stream_ISURI.nextNode()
 22006  
                         , root_1);
 22007  
 
 22008  2
                         adaptor.addChild(root_1, stream_expression.nextTree());
 22009  
 
 22010  2
                         adaptor.addChild(root_0, root_1);
 22011  
                         }
 22012  
 
 22013  
                     }
 22014  
 
 22015  
 
 22016  2
                     retval.tree = root_0;
 22017  
 
 22018  
                     }
 22019  2
                     break;
 22020  
                 case 49 :
 22021  
                     // com\\googlecode\\sparkleg\\Sparql.g:593:7: ISBLANK OPEN_BRACE expression CLOSE_BRACE
 22022  
                     {
 22023  8
                     ISBLANK590=(Token)match(input,ISBLANK,FOLLOW_ISBLANK_in_builtInCall6151);  
 22024  8
                     stream_ISBLANK.add(ISBLANK590);
 22025  
 
 22026  
 
 22027  8
                     OPEN_BRACE591=(Token)match(input,OPEN_BRACE,FOLLOW_OPEN_BRACE_in_builtInCall6153);  
 22028  8
                     stream_OPEN_BRACE.add(OPEN_BRACE591);
 22029  
 
 22030  
 
 22031  8
                     pushFollow(FOLLOW_expression_in_builtInCall6155);
 22032  8
                     expression592=expression();
 22033  
 
 22034  8
                     state._fsp--;
 22035  
 
 22036  8
                     stream_expression.add(expression592.getTree());
 22037  
 
 22038  8
                     CLOSE_BRACE593=(Token)match(input,CLOSE_BRACE,FOLLOW_CLOSE_BRACE_in_builtInCall6157);  
 22039  8
                     stream_CLOSE_BRACE.add(CLOSE_BRACE593);
 22040  
 
 22041  
 
 22042  
                     // AST REWRITE
 22043  
                     // elements: ISBLANK, expression
 22044  
                     // token labels: 
 22045  
                     // rule labels: retval
 22046  
                     // token list labels: 
 22047  
                     // rule list labels: 
 22048  
                     // wildcard labels: 
 22049  8
                     retval.tree = root_0;
 22050  8
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 22051  
 
 22052  8
                     root_0 = (Object)adaptor.nil();
 22053  
                     // 593:49: -> ^( ISBLANK expression )
 22054  
                     {
 22055  
                         // com\\googlecode\\sparkleg\\Sparql.g:593:52: ^( ISBLANK expression )
 22056  
                         {
 22057  8
                         Object root_1 = (Object)adaptor.nil();
 22058  8
                         root_1 = (Object)adaptor.becomeRoot(
 22059  
                         stream_ISBLANK.nextNode()
 22060  
                         , root_1);
 22061  
 
 22062  8
                         adaptor.addChild(root_1, stream_expression.nextTree());
 22063  
 
 22064  8
                         adaptor.addChild(root_0, root_1);
 22065  
                         }
 22066  
 
 22067  
                     }
 22068  
 
 22069  
 
 22070  8
                     retval.tree = root_0;
 22071  
 
 22072  
                     }
 22073  8
                     break;
 22074  
                 case 50 :
 22075  
                     // com\\googlecode\\sparkleg\\Sparql.g:594:7: ISLITERAL OPEN_BRACE expression CLOSE_BRACE
 22076  
                     {
 22077  8
                     ISLITERAL594=(Token)match(input,ISLITERAL,FOLLOW_ISLITERAL_in_builtInCall6174);  
 22078  8
                     stream_ISLITERAL.add(ISLITERAL594);
 22079  
 
 22080  
 
 22081  8
                     OPEN_BRACE595=(Token)match(input,OPEN_BRACE,FOLLOW_OPEN_BRACE_in_builtInCall6176);  
 22082  8
                     stream_OPEN_BRACE.add(OPEN_BRACE595);
 22083  
 
 22084  
 
 22085  8
                     pushFollow(FOLLOW_expression_in_builtInCall6178);
 22086  8
                     expression596=expression();
 22087  
 
 22088  8
                     state._fsp--;
 22089  
 
 22090  8
                     stream_expression.add(expression596.getTree());
 22091  
 
 22092  8
                     CLOSE_BRACE597=(Token)match(input,CLOSE_BRACE,FOLLOW_CLOSE_BRACE_in_builtInCall6180);  
 22093  8
                     stream_CLOSE_BRACE.add(CLOSE_BRACE597);
 22094  
 
 22095  
 
 22096  
                     // AST REWRITE
 22097  
                     // elements: expression, ISLITERAL
 22098  
                     // token labels: 
 22099  
                     // rule labels: retval
 22100  
                     // token list labels: 
 22101  
                     // rule list labels: 
 22102  
                     // wildcard labels: 
 22103  8
                     retval.tree = root_0;
 22104  8
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 22105  
 
 22106  8
                     root_0 = (Object)adaptor.nil();
 22107  
                     // 594:51: -> ^( ISLITERAL expression )
 22108  
                     {
 22109  
                         // com\\googlecode\\sparkleg\\Sparql.g:594:54: ^( ISLITERAL expression )
 22110  
                         {
 22111  8
                         Object root_1 = (Object)adaptor.nil();
 22112  8
                         root_1 = (Object)adaptor.becomeRoot(
 22113  
                         stream_ISLITERAL.nextNode()
 22114  
                         , root_1);
 22115  
 
 22116  8
                         adaptor.addChild(root_1, stream_expression.nextTree());
 22117  
 
 22118  8
                         adaptor.addChild(root_0, root_1);
 22119  
                         }
 22120  
 
 22121  
                     }
 22122  
 
 22123  
 
 22124  8
                     retval.tree = root_0;
 22125  
 
 22126  
                     }
 22127  8
                     break;
 22128  
                 case 51 :
 22129  
                     // com\\googlecode\\sparkleg\\Sparql.g:595:7: ISNUMERIC OPEN_BRACE expression CLOSE_BRACE
 22130  
                     {
 22131  4
                     ISNUMERIC598=(Token)match(input,ISNUMERIC,FOLLOW_ISNUMERIC_in_builtInCall6196);  
 22132  4
                     stream_ISNUMERIC.add(ISNUMERIC598);
 22133  
 
 22134  
 
 22135  4
                     OPEN_BRACE599=(Token)match(input,OPEN_BRACE,FOLLOW_OPEN_BRACE_in_builtInCall6198);  
 22136  4
                     stream_OPEN_BRACE.add(OPEN_BRACE599);
 22137  
 
 22138  
 
 22139  4
                     pushFollow(FOLLOW_expression_in_builtInCall6200);
 22140  4
                     expression600=expression();
 22141  
 
 22142  4
                     state._fsp--;
 22143  
 
 22144  4
                     stream_expression.add(expression600.getTree());
 22145  
 
 22146  4
                     CLOSE_BRACE601=(Token)match(input,CLOSE_BRACE,FOLLOW_CLOSE_BRACE_in_builtInCall6202);  
 22147  4
                     stream_CLOSE_BRACE.add(CLOSE_BRACE601);
 22148  
 
 22149  
 
 22150  
                     // AST REWRITE
 22151  
                     // elements: ISNUMERIC, expression
 22152  
                     // token labels: 
 22153  
                     // rule labels: retval
 22154  
                     // token list labels: 
 22155  
                     // rule list labels: 
 22156  
                     // wildcard labels: 
 22157  4
                     retval.tree = root_0;
 22158  4
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 22159  
 
 22160  4
                     root_0 = (Object)adaptor.nil();
 22161  
                     // 595:51: -> ^( ISNUMERIC expression )
 22162  
                     {
 22163  
                         // com\\googlecode\\sparkleg\\Sparql.g:595:54: ^( ISNUMERIC expression )
 22164  
                         {
 22165  4
                         Object root_1 = (Object)adaptor.nil();
 22166  4
                         root_1 = (Object)adaptor.becomeRoot(
 22167  
                         stream_ISNUMERIC.nextNode()
 22168  
                         , root_1);
 22169  
 
 22170  4
                         adaptor.addChild(root_1, stream_expression.nextTree());
 22171  
 
 22172  4
                         adaptor.addChild(root_0, root_1);
 22173  
                         }
 22174  
 
 22175  
                     }
 22176  
 
 22177  
 
 22178  4
                     retval.tree = root_0;
 22179  
 
 22180  
                     }
 22181  4
                     break;
 22182  
                 case 52 :
 22183  
                     // com\\googlecode\\sparkleg\\Sparql.g:596:7: regexExpression
 22184  
                     {
 22185  42
                     pushFollow(FOLLOW_regexExpression_in_builtInCall6218);
 22186  42
                     regexExpression602=regexExpression();
 22187  
 
 22188  42
                     state._fsp--;
 22189  
 
 22190  42
                     stream_regexExpression.add(regexExpression602.getTree());
 22191  
 
 22192  
                     // AST REWRITE
 22193  
                     // elements: regexExpression
 22194  
                     // token labels: 
 22195  
                     // rule labels: retval
 22196  
                     // token list labels: 
 22197  
                     // rule list labels: 
 22198  
                     // wildcard labels: 
 22199  42
                     retval.tree = root_0;
 22200  42
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 22201  
 
 22202  42
                     root_0 = (Object)adaptor.nil();
 22203  
                     // 596:23: -> regexExpression
 22204  
                     {
 22205  42
                         adaptor.addChild(root_0, stream_regexExpression.nextTree());
 22206  
 
 22207  
                     }
 22208  
 
 22209  
 
 22210  42
                     retval.tree = root_0;
 22211  
 
 22212  
                     }
 22213  42
                     break;
 22214  
                 case 53 :
 22215  
                     // com\\googlecode\\sparkleg\\Sparql.g:597:7: existsFunction
 22216  
                     {
 22217  20
                     pushFollow(FOLLOW_existsFunction_in_builtInCall6230);
 22218  20
                     existsFunction603=existsFunction();
 22219  
 
 22220  20
                     state._fsp--;
 22221  
 
 22222  20
                     stream_existsFunction.add(existsFunction603.getTree());
 22223  
 
 22224  
                     // AST REWRITE
 22225  
                     // elements: existsFunction
 22226  
                     // token labels: 
 22227  
                     // rule labels: retval
 22228  
                     // token list labels: 
 22229  
                     // rule list labels: 
 22230  
                     // wildcard labels: 
 22231  20
                     retval.tree = root_0;
 22232  20
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 22233  
 
 22234  20
                     root_0 = (Object)adaptor.nil();
 22235  
                     // 597:22: -> existsFunction
 22236  
                     {
 22237  20
                         adaptor.addChild(root_0, stream_existsFunction.nextTree());
 22238  
 
 22239  
                     }
 22240  
 
 22241  
 
 22242  20
                     retval.tree = root_0;
 22243  
 
 22244  
                     }
 22245  20
                     break;
 22246  
                 case 54 :
 22247  
                     // com\\googlecode\\sparkleg\\Sparql.g:598:7: notExistsFunction
 22248  
                     {
 22249  46
                     pushFollow(FOLLOW_notExistsFunction_in_builtInCall6242);
 22250  46
                     notExistsFunction604=notExistsFunction();
 22251  
 
 22252  46
                     state._fsp--;
 22253  
 
 22254  46
                     stream_notExistsFunction.add(notExistsFunction604.getTree());
 22255  
 
 22256  
                     // AST REWRITE
 22257  
                     // elements: notExistsFunction
 22258  
                     // token labels: 
 22259  
                     // rule labels: retval
 22260  
                     // token list labels: 
 22261  
                     // rule list labels: 
 22262  
                     // wildcard labels: 
 22263  46
                     retval.tree = root_0;
 22264  46
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 22265  
 
 22266  46
                     root_0 = (Object)adaptor.nil();
 22267  
                     // 598:25: -> notExistsFunction
 22268  
                     {
 22269  46
                         adaptor.addChild(root_0, stream_notExistsFunction.nextTree());
 22270  
 
 22271  
                     }
 22272  
 
 22273  
 
 22274  46
                     retval.tree = root_0;
 22275  
 
 22276  
                     }
 22277  
                     break;
 22278  
 
 22279  
             }
 22280  532
             retval.stop = input.LT(-1);
 22281  
 
 22282  
 
 22283  532
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 22284  532
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 22285  
 
 22286  
         }
 22287  0
         catch (RecognitionException re) {
 22288  0
             reportError(re);
 22289  0
             recover(input,re);
 22290  0
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 22291  
 
 22292  
         }
 22293  
 
 22294  0
         finally {
 22295  
                 // do for sure before leaving
 22296  532
         }
 22297  532
         return retval;
 22298  
     }
 22299  
     // $ANTLR end "builtInCall"
 22300  
 
 22301  
 
 22302  42
     public static class regexExpression_return extends ParserRuleReturnScope {
 22303  
         Object tree;
 22304  42
         public Object getTree() { return tree; }
 22305  
     };
 22306  
 
 22307  
 
 22308  
     // $ANTLR start "regexExpression"
 22309  
     // com\\googlecode\\sparkleg\\Sparql.g:601:1: regexExpression : REGEX OPEN_BRACE expression COMMA expression ( COMMA expression )? CLOSE_BRACE -> ^( REGEX ( expression )* ) ;
 22310  
     public final SparqlParser.regexExpression_return regexExpression() throws RecognitionException {
 22311  42
         SparqlParser.regexExpression_return retval = new SparqlParser.regexExpression_return();
 22312  42
         retval.start = input.LT(1);
 22313  
 
 22314  
 
 22315  42
         Object root_0 = null;
 22316  
 
 22317  42
         Token REGEX605=null;
 22318  42
         Token OPEN_BRACE606=null;
 22319  42
         Token COMMA608=null;
 22320  42
         Token COMMA610=null;
 22321  42
         Token CLOSE_BRACE612=null;
 22322  42
         SparqlParser.expression_return expression607 =null;
 22323  
 
 22324  42
         SparqlParser.expression_return expression609 =null;
 22325  
 
 22326  42
         SparqlParser.expression_return expression611 =null;
 22327  
 
 22328  
 
 22329  42
         Object REGEX605_tree=null;
 22330  42
         Object OPEN_BRACE606_tree=null;
 22331  42
         Object COMMA608_tree=null;
 22332  42
         Object COMMA610_tree=null;
 22333  42
         Object CLOSE_BRACE612_tree=null;
 22334  42
         RewriteRuleTokenStream stream_REGEX=new RewriteRuleTokenStream(adaptor,"token REGEX");
 22335  42
         RewriteRuleTokenStream stream_CLOSE_BRACE=new RewriteRuleTokenStream(adaptor,"token CLOSE_BRACE");
 22336  42
         RewriteRuleTokenStream stream_COMMA=new RewriteRuleTokenStream(adaptor,"token COMMA");
 22337  42
         RewriteRuleTokenStream stream_OPEN_BRACE=new RewriteRuleTokenStream(adaptor,"token OPEN_BRACE");
 22338  42
         RewriteRuleSubtreeStream stream_expression=new RewriteRuleSubtreeStream(adaptor,"rule expression");
 22339  
         try {
 22340  
             // com\\googlecode\\sparkleg\\Sparql.g:602:5: ( REGEX OPEN_BRACE expression COMMA expression ( COMMA expression )? CLOSE_BRACE -> ^( REGEX ( expression )* ) )
 22341  
             // com\\googlecode\\sparkleg\\Sparql.g:602:7: REGEX OPEN_BRACE expression COMMA expression ( COMMA expression )? CLOSE_BRACE
 22342  
             {
 22343  42
             REGEX605=(Token)match(input,REGEX,FOLLOW_REGEX_in_regexExpression6263);  
 22344  42
             stream_REGEX.add(REGEX605);
 22345  
 
 22346  
 
 22347  42
             OPEN_BRACE606=(Token)match(input,OPEN_BRACE,FOLLOW_OPEN_BRACE_in_regexExpression6265);  
 22348  42
             stream_OPEN_BRACE.add(OPEN_BRACE606);
 22349  
 
 22350  
 
 22351  42
             pushFollow(FOLLOW_expression_in_regexExpression6267);
 22352  42
             expression607=expression();
 22353  
 
 22354  42
             state._fsp--;
 22355  
 
 22356  42
             stream_expression.add(expression607.getTree());
 22357  
 
 22358  42
             COMMA608=(Token)match(input,COMMA,FOLLOW_COMMA_in_regexExpression6269);  
 22359  42
             stream_COMMA.add(COMMA608);
 22360  
 
 22361  
 
 22362  42
             pushFollow(FOLLOW_expression_in_regexExpression6271);
 22363  42
             expression609=expression();
 22364  
 
 22365  42
             state._fsp--;
 22366  
 
 22367  42
             stream_expression.add(expression609.getTree());
 22368  
 
 22369  
             // com\\googlecode\\sparkleg\\Sparql.g:602:52: ( COMMA expression )?
 22370  42
             int alt127=2;
 22371  42
             switch ( input.LA(1) ) {
 22372  
                 case COMMA:
 22373  
                     {
 22374  12
                     alt127=1;
 22375  
                     }
 22376  
                     break;
 22377  
             }
 22378  
 
 22379  42
             switch (alt127) {
 22380  
                 case 1 :
 22381  
                     // com\\googlecode\\sparkleg\\Sparql.g:602:53: COMMA expression
 22382  
                     {
 22383  12
                     COMMA610=(Token)match(input,COMMA,FOLLOW_COMMA_in_regexExpression6274);  
 22384  12
                     stream_COMMA.add(COMMA610);
 22385  
 
 22386  
 
 22387  12
                     pushFollow(FOLLOW_expression_in_regexExpression6276);
 22388  12
                     expression611=expression();
 22389  
 
 22390  12
                     state._fsp--;
 22391  
 
 22392  12
                     stream_expression.add(expression611.getTree());
 22393  
 
 22394  
                     }
 22395  
                     break;
 22396  
 
 22397  
             }
 22398  
 
 22399  
 
 22400  42
             CLOSE_BRACE612=(Token)match(input,CLOSE_BRACE,FOLLOW_CLOSE_BRACE_in_regexExpression6280);  
 22401  42
             stream_CLOSE_BRACE.add(CLOSE_BRACE612);
 22402  
 
 22403  
 
 22404  
             // AST REWRITE
 22405  
             // elements: REGEX, expression
 22406  
             // token labels: 
 22407  
             // rule labels: retval
 22408  
             // token list labels: 
 22409  
             // rule list labels: 
 22410  
             // wildcard labels: 
 22411  42
             retval.tree = root_0;
 22412  42
             RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 22413  
 
 22414  42
             root_0 = (Object)adaptor.nil();
 22415  
             // 602:84: -> ^( REGEX ( expression )* )
 22416  
             {
 22417  
                 // com\\googlecode\\sparkleg\\Sparql.g:602:87: ^( REGEX ( expression )* )
 22418  
                 {
 22419  42
                 Object root_1 = (Object)adaptor.nil();
 22420  42
                 root_1 = (Object)adaptor.becomeRoot(
 22421  
                 stream_REGEX.nextNode()
 22422  
                 , root_1);
 22423  
 
 22424  
                 // com\\googlecode\\sparkleg\\Sparql.g:602:95: ( expression )*
 22425  138
                 while ( stream_expression.hasNext() ) {
 22426  96
                     adaptor.addChild(root_1, stream_expression.nextTree());
 22427  
 
 22428  
                 }
 22429  42
                 stream_expression.reset();
 22430  
 
 22431  42
                 adaptor.addChild(root_0, root_1);
 22432  
                 }
 22433  
 
 22434  
             }
 22435  
 
 22436  
 
 22437  42
             retval.tree = root_0;
 22438  
 
 22439  
             }
 22440  
 
 22441  42
             retval.stop = input.LT(-1);
 22442  
 
 22443  
 
 22444  42
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 22445  42
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 22446  
 
 22447  
         }
 22448  0
         catch (RecognitionException re) {
 22449  0
             reportError(re);
 22450  0
             recover(input,re);
 22451  0
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 22452  
 
 22453  
         }
 22454  
 
 22455  0
         finally {
 22456  
                 // do for sure before leaving
 22457  42
         }
 22458  42
         return retval;
 22459  
     }
 22460  
     // $ANTLR end "regexExpression"
 22461  
 
 22462  
 
 22463  4
     public static class subStringExpression_return extends ParserRuleReturnScope {
 22464  
         Object tree;
 22465  4
         public Object getTree() { return tree; }
 22466  
     };
 22467  
 
 22468  
 
 22469  
     // $ANTLR start "subStringExpression"
 22470  
     // com\\googlecode\\sparkleg\\Sparql.g:605:1: subStringExpression : SUBSTR OPEN_BRACE expression COMMA expression ( COMMA expression )? CLOSE_BRACE -> ^( SUBSTR ( expression )* ) ;
 22471  
     public final SparqlParser.subStringExpression_return subStringExpression() throws RecognitionException {
 22472  4
         SparqlParser.subStringExpression_return retval = new SparqlParser.subStringExpression_return();
 22473  4
         retval.start = input.LT(1);
 22474  
 
 22475  
 
 22476  4
         Object root_0 = null;
 22477  
 
 22478  4
         Token SUBSTR613=null;
 22479  4
         Token OPEN_BRACE614=null;
 22480  4
         Token COMMA616=null;
 22481  4
         Token COMMA618=null;
 22482  4
         Token CLOSE_BRACE620=null;
 22483  4
         SparqlParser.expression_return expression615 =null;
 22484  
 
 22485  4
         SparqlParser.expression_return expression617 =null;
 22486  
 
 22487  4
         SparqlParser.expression_return expression619 =null;
 22488  
 
 22489  
 
 22490  4
         Object SUBSTR613_tree=null;
 22491  4
         Object OPEN_BRACE614_tree=null;
 22492  4
         Object COMMA616_tree=null;
 22493  4
         Object COMMA618_tree=null;
 22494  4
         Object CLOSE_BRACE620_tree=null;
 22495  4
         RewriteRuleTokenStream stream_CLOSE_BRACE=new RewriteRuleTokenStream(adaptor,"token CLOSE_BRACE");
 22496  4
         RewriteRuleTokenStream stream_SUBSTR=new RewriteRuleTokenStream(adaptor,"token SUBSTR");
 22497  4
         RewriteRuleTokenStream stream_COMMA=new RewriteRuleTokenStream(adaptor,"token COMMA");
 22498  4
         RewriteRuleTokenStream stream_OPEN_BRACE=new RewriteRuleTokenStream(adaptor,"token OPEN_BRACE");
 22499  4
         RewriteRuleSubtreeStream stream_expression=new RewriteRuleSubtreeStream(adaptor,"rule expression");
 22500  
         try {
 22501  
             // com\\googlecode\\sparkleg\\Sparql.g:606:5: ( SUBSTR OPEN_BRACE expression COMMA expression ( COMMA expression )? CLOSE_BRACE -> ^( SUBSTR ( expression )* ) )
 22502  
             // com\\googlecode\\sparkleg\\Sparql.g:606:7: SUBSTR OPEN_BRACE expression COMMA expression ( COMMA expression )? CLOSE_BRACE
 22503  
             {
 22504  4
             SUBSTR613=(Token)match(input,SUBSTR,FOLLOW_SUBSTR_in_subStringExpression6310);  
 22505  4
             stream_SUBSTR.add(SUBSTR613);
 22506  
 
 22507  
 
 22508  4
             OPEN_BRACE614=(Token)match(input,OPEN_BRACE,FOLLOW_OPEN_BRACE_in_subStringExpression6312);  
 22509  4
             stream_OPEN_BRACE.add(OPEN_BRACE614);
 22510  
 
 22511  
 
 22512  4
             pushFollow(FOLLOW_expression_in_subStringExpression6314);
 22513  4
             expression615=expression();
 22514  
 
 22515  4
             state._fsp--;
 22516  
 
 22517  4
             stream_expression.add(expression615.getTree());
 22518  
 
 22519  4
             COMMA616=(Token)match(input,COMMA,FOLLOW_COMMA_in_subStringExpression6316);  
 22520  4
             stream_COMMA.add(COMMA616);
 22521  
 
 22522  
 
 22523  4
             pushFollow(FOLLOW_expression_in_subStringExpression6318);
 22524  4
             expression617=expression();
 22525  
 
 22526  4
             state._fsp--;
 22527  
 
 22528  4
             stream_expression.add(expression617.getTree());
 22529  
 
 22530  
             // com\\googlecode\\sparkleg\\Sparql.g:606:53: ( COMMA expression )?
 22531  4
             int alt128=2;
 22532  4
             switch ( input.LA(1) ) {
 22533  
                 case COMMA:
 22534  
                     {
 22535  2
                     alt128=1;
 22536  
                     }
 22537  
                     break;
 22538  
             }
 22539  
 
 22540  4
             switch (alt128) {
 22541  
                 case 1 :
 22542  
                     // com\\googlecode\\sparkleg\\Sparql.g:606:54: COMMA expression
 22543  
                     {
 22544  2
                     COMMA618=(Token)match(input,COMMA,FOLLOW_COMMA_in_subStringExpression6321);  
 22545  2
                     stream_COMMA.add(COMMA618);
 22546  
 
 22547  
 
 22548  2
                     pushFollow(FOLLOW_expression_in_subStringExpression6323);
 22549  2
                     expression619=expression();
 22550  
 
 22551  2
                     state._fsp--;
 22552  
 
 22553  2
                     stream_expression.add(expression619.getTree());
 22554  
 
 22555  
                     }
 22556  
                     break;
 22557  
 
 22558  
             }
 22559  
 
 22560  
 
 22561  4
             CLOSE_BRACE620=(Token)match(input,CLOSE_BRACE,FOLLOW_CLOSE_BRACE_in_subStringExpression6327);  
 22562  4
             stream_CLOSE_BRACE.add(CLOSE_BRACE620);
 22563  
 
 22564  
 
 22565  
             // AST REWRITE
 22566  
             // elements: expression, SUBSTR
 22567  
             // token labels: 
 22568  
             // rule labels: retval
 22569  
             // token list labels: 
 22570  
             // rule list labels: 
 22571  
             // wildcard labels: 
 22572  4
             retval.tree = root_0;
 22573  4
             RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 22574  
 
 22575  4
             root_0 = (Object)adaptor.nil();
 22576  
             // 606:85: -> ^( SUBSTR ( expression )* )
 22577  
             {
 22578  
                 // com\\googlecode\\sparkleg\\Sparql.g:606:88: ^( SUBSTR ( expression )* )
 22579  
                 {
 22580  4
                 Object root_1 = (Object)adaptor.nil();
 22581  4
                 root_1 = (Object)adaptor.becomeRoot(
 22582  
                 stream_SUBSTR.nextNode()
 22583  
                 , root_1);
 22584  
 
 22585  
                 // com\\googlecode\\sparkleg\\Sparql.g:606:97: ( expression )*
 22586  14
                 while ( stream_expression.hasNext() ) {
 22587  10
                     adaptor.addChild(root_1, stream_expression.nextTree());
 22588  
 
 22589  
                 }
 22590  4
                 stream_expression.reset();
 22591  
 
 22592  4
                 adaptor.addChild(root_0, root_1);
 22593  
                 }
 22594  
 
 22595  
             }
 22596  
 
 22597  
 
 22598  4
             retval.tree = root_0;
 22599  
 
 22600  
             }
 22601  
 
 22602  4
             retval.stop = input.LT(-1);
 22603  
 
 22604  
 
 22605  4
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 22606  4
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 22607  
 
 22608  
         }
 22609  0
         catch (RecognitionException re) {
 22610  0
             reportError(re);
 22611  0
             recover(input,re);
 22612  0
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 22613  
 
 22614  
         }
 22615  
 
 22616  0
         finally {
 22617  
                 // do for sure before leaving
 22618  4
         }
 22619  4
         return retval;
 22620  
     }
 22621  
     // $ANTLR end "subStringExpression"
 22622  
 
 22623  
 
 22624  20
     public static class existsFunction_return extends ParserRuleReturnScope {
 22625  
         Object tree;
 22626  20
         public Object getTree() { return tree; }
 22627  
     };
 22628  
 
 22629  
 
 22630  
     // $ANTLR start "existsFunction"
 22631  
     // com\\googlecode\\sparkleg\\Sparql.g:609:1: existsFunction : EXISTS groupGraphPattern -> ^( EXISTS groupGraphPattern ) ;
 22632  
     public final SparqlParser.existsFunction_return existsFunction() throws RecognitionException {
 22633  20
         SparqlParser.existsFunction_return retval = new SparqlParser.existsFunction_return();
 22634  20
         retval.start = input.LT(1);
 22635  
 
 22636  
 
 22637  20
         Object root_0 = null;
 22638  
 
 22639  20
         Token EXISTS621=null;
 22640  20
         SparqlParser.groupGraphPattern_return groupGraphPattern622 =null;
 22641  
 
 22642  
 
 22643  20
         Object EXISTS621_tree=null;
 22644  20
         RewriteRuleTokenStream stream_EXISTS=new RewriteRuleTokenStream(adaptor,"token EXISTS");
 22645  20
         RewriteRuleSubtreeStream stream_groupGraphPattern=new RewriteRuleSubtreeStream(adaptor,"rule groupGraphPattern");
 22646  
         try {
 22647  
             // com\\googlecode\\sparkleg\\Sparql.g:610:5: ( EXISTS groupGraphPattern -> ^( EXISTS groupGraphPattern ) )
 22648  
             // com\\googlecode\\sparkleg\\Sparql.g:610:7: EXISTS groupGraphPattern
 22649  
             {
 22650  20
             EXISTS621=(Token)match(input,EXISTS,FOLLOW_EXISTS_in_existsFunction6357);  
 22651  20
             stream_EXISTS.add(EXISTS621);
 22652  
 
 22653  
 
 22654  20
             pushFollow(FOLLOW_groupGraphPattern_in_existsFunction6359);
 22655  20
             groupGraphPattern622=groupGraphPattern();
 22656  
 
 22657  20
             state._fsp--;
 22658  
 
 22659  20
             stream_groupGraphPattern.add(groupGraphPattern622.getTree());
 22660  
 
 22661  
             // AST REWRITE
 22662  
             // elements: groupGraphPattern, EXISTS
 22663  
             // token labels: 
 22664  
             // rule labels: retval
 22665  
             // token list labels: 
 22666  
             // rule list labels: 
 22667  
             // wildcard labels: 
 22668  20
             retval.tree = root_0;
 22669  20
             RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 22670  
 
 22671  20
             root_0 = (Object)adaptor.nil();
 22672  
             // 610:32: -> ^( EXISTS groupGraphPattern )
 22673  
             {
 22674  
                 // com\\googlecode\\sparkleg\\Sparql.g:610:35: ^( EXISTS groupGraphPattern )
 22675  
                 {
 22676  20
                 Object root_1 = (Object)adaptor.nil();
 22677  20
                 root_1 = (Object)adaptor.becomeRoot(
 22678  
                 stream_EXISTS.nextNode()
 22679  
                 , root_1);
 22680  
 
 22681  20
                 adaptor.addChild(root_1, stream_groupGraphPattern.nextTree());
 22682  
 
 22683  20
                 adaptor.addChild(root_0, root_1);
 22684  
                 }
 22685  
 
 22686  
             }
 22687  
 
 22688  
 
 22689  20
             retval.tree = root_0;
 22690  
 
 22691  
             }
 22692  
 
 22693  20
             retval.stop = input.LT(-1);
 22694  
 
 22695  
 
 22696  20
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 22697  20
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 22698  
 
 22699  
         }
 22700  0
         catch (RecognitionException re) {
 22701  0
             reportError(re);
 22702  0
             recover(input,re);
 22703  0
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 22704  
 
 22705  
         }
 22706  
 
 22707  0
         finally {
 22708  
                 // do for sure before leaving
 22709  20
         }
 22710  20
         return retval;
 22711  
     }
 22712  
     // $ANTLR end "existsFunction"
 22713  
 
 22714  
 
 22715  46
     public static class notExistsFunction_return extends ParserRuleReturnScope {
 22716  
         Object tree;
 22717  46
         public Object getTree() { return tree; }
 22718  
     };
 22719  
 
 22720  
 
 22721  
     // $ANTLR start "notExistsFunction"
 22722  
     // com\\googlecode\\sparkleg\\Sparql.g:613:1: notExistsFunction : NOT EXISTS groupGraphPattern -> ^( NOT_EXISTS groupGraphPattern ) ;
 22723  
     public final SparqlParser.notExistsFunction_return notExistsFunction() throws RecognitionException {
 22724  46
         SparqlParser.notExistsFunction_return retval = new SparqlParser.notExistsFunction_return();
 22725  46
         retval.start = input.LT(1);
 22726  
 
 22727  
 
 22728  46
         Object root_0 = null;
 22729  
 
 22730  46
         Token NOT623=null;
 22731  46
         Token EXISTS624=null;
 22732  46
         SparqlParser.groupGraphPattern_return groupGraphPattern625 =null;
 22733  
 
 22734  
 
 22735  46
         Object NOT623_tree=null;
 22736  46
         Object EXISTS624_tree=null;
 22737  46
         RewriteRuleTokenStream stream_NOT=new RewriteRuleTokenStream(adaptor,"token NOT");
 22738  46
         RewriteRuleTokenStream stream_EXISTS=new RewriteRuleTokenStream(adaptor,"token EXISTS");
 22739  46
         RewriteRuleSubtreeStream stream_groupGraphPattern=new RewriteRuleSubtreeStream(adaptor,"rule groupGraphPattern");
 22740  
         try {
 22741  
             // com\\googlecode\\sparkleg\\Sparql.g:614:5: ( NOT EXISTS groupGraphPattern -> ^( NOT_EXISTS groupGraphPattern ) )
 22742  
             // com\\googlecode\\sparkleg\\Sparql.g:614:7: NOT EXISTS groupGraphPattern
 22743  
             {
 22744  46
             NOT623=(Token)match(input,NOT,FOLLOW_NOT_in_notExistsFunction6384);  
 22745  46
             stream_NOT.add(NOT623);
 22746  
 
 22747  
 
 22748  46
             EXISTS624=(Token)match(input,EXISTS,FOLLOW_EXISTS_in_notExistsFunction6386);  
 22749  46
             stream_EXISTS.add(EXISTS624);
 22750  
 
 22751  
 
 22752  46
             pushFollow(FOLLOW_groupGraphPattern_in_notExistsFunction6388);
 22753  46
             groupGraphPattern625=groupGraphPattern();
 22754  
 
 22755  46
             state._fsp--;
 22756  
 
 22757  46
             stream_groupGraphPattern.add(groupGraphPattern625.getTree());
 22758  
 
 22759  
             // AST REWRITE
 22760  
             // elements: groupGraphPattern
 22761  
             // token labels: 
 22762  
             // rule labels: retval
 22763  
             // token list labels: 
 22764  
             // rule list labels: 
 22765  
             // wildcard labels: 
 22766  46
             retval.tree = root_0;
 22767  46
             RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 22768  
 
 22769  46
             root_0 = (Object)adaptor.nil();
 22770  
             // 614:36: -> ^( NOT_EXISTS groupGraphPattern )
 22771  
             {
 22772  
                 // com\\googlecode\\sparkleg\\Sparql.g:614:39: ^( NOT_EXISTS groupGraphPattern )
 22773  
                 {
 22774  46
                 Object root_1 = (Object)adaptor.nil();
 22775  46
                 root_1 = (Object)adaptor.becomeRoot(
 22776  
                 (Object)adaptor.create(NOT_EXISTS, "NOT_EXISTS")
 22777  
                 , root_1);
 22778  
 
 22779  46
                 adaptor.addChild(root_1, stream_groupGraphPattern.nextTree());
 22780  
 
 22781  46
                 adaptor.addChild(root_0, root_1);
 22782  
                 }
 22783  
 
 22784  
             }
 22785  
 
 22786  
 
 22787  46
             retval.tree = root_0;
 22788  
 
 22789  
             }
 22790  
 
 22791  46
             retval.stop = input.LT(-1);
 22792  
 
 22793  
 
 22794  46
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 22795  46
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 22796  
 
 22797  
         }
 22798  0
         catch (RecognitionException re) {
 22799  0
             reportError(re);
 22800  0
             recover(input,re);
 22801  0
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 22802  
 
 22803  
         }
 22804  
 
 22805  0
         finally {
 22806  
                 // do for sure before leaving
 22807  46
         }
 22808  46
         return retval;
 22809  
     }
 22810  
     // $ANTLR end "notExistsFunction"
 22811  
 
 22812  
 
 22813  106
     public static class aggregate_return extends ParserRuleReturnScope {
 22814  
         Object tree;
 22815  106
         public Object getTree() { return tree; }
 22816  
     };
 22817  
 
 22818  
 
 22819  
     // $ANTLR start "aggregate"
 22820  
     // com\\googlecode\\sparkleg\\Sparql.g:617:1: aggregate : ( COUNT OPEN_BRACE ( DISTINCT )? ( ASTERISK | expression ) CLOSE_BRACE -> ^( COUNT ( DISTINCT )* ( ASTERISK )* ( expression )* ) | SUM OPEN_BRACE ( DISTINCT )? expression CLOSE_BRACE -> ^( SUM ( DISTINCT )* expression ) | MIN OPEN_BRACE ( DISTINCT )? expression CLOSE_BRACE -> ^( MIN ( DISTINCT )* expression ) | MAX OPEN_BRACE ( DISTINCT )? expression CLOSE_BRACE -> ^( MAX ( DISTINCT )* expression ) | AVG OPEN_BRACE ( DISTINCT )? expression CLOSE_BRACE -> ^( AVG ( DISTINCT )* expression ) | SAMPLE OPEN_BRACE ( DISTINCT )? expression CLOSE_BRACE -> ^( SAMPLE ( DISTINCT )? expression ) | GROUP_CONCAT OPEN_BRACE ( DISTINCT )? expression ( SEMICOLON SEPARATOR EQUAL string )? CLOSE_BRACE -> ^( GROUP_CONCAT ( DISTINCT )* expression ( string )* ) );
 22821  
     public final SparqlParser.aggregate_return aggregate() throws RecognitionException {
 22822  106
         SparqlParser.aggregate_return retval = new SparqlParser.aggregate_return();
 22823  106
         retval.start = input.LT(1);
 22824  
 
 22825  
 
 22826  106
         Object root_0 = null;
 22827  
 
 22828  106
         Token COUNT626=null;
 22829  106
         Token OPEN_BRACE627=null;
 22830  106
         Token DISTINCT628=null;
 22831  106
         Token ASTERISK629=null;
 22832  106
         Token CLOSE_BRACE631=null;
 22833  106
         Token SUM632=null;
 22834  106
         Token OPEN_BRACE633=null;
 22835  106
         Token DISTINCT634=null;
 22836  106
         Token CLOSE_BRACE636=null;
 22837  106
         Token MIN637=null;
 22838  106
         Token OPEN_BRACE638=null;
 22839  106
         Token DISTINCT639=null;
 22840  106
         Token CLOSE_BRACE641=null;
 22841  106
         Token MAX642=null;
 22842  106
         Token OPEN_BRACE643=null;
 22843  106
         Token DISTINCT644=null;
 22844  106
         Token CLOSE_BRACE646=null;
 22845  106
         Token AVG647=null;
 22846  106
         Token OPEN_BRACE648=null;
 22847  106
         Token DISTINCT649=null;
 22848  106
         Token CLOSE_BRACE651=null;
 22849  106
         Token SAMPLE652=null;
 22850  106
         Token OPEN_BRACE653=null;
 22851  106
         Token DISTINCT654=null;
 22852  106
         Token CLOSE_BRACE656=null;
 22853  106
         Token GROUP_CONCAT657=null;
 22854  106
         Token OPEN_BRACE658=null;
 22855  106
         Token DISTINCT659=null;
 22856  106
         Token SEMICOLON661=null;
 22857  106
         Token SEPARATOR662=null;
 22858  106
         Token EQUAL663=null;
 22859  106
         Token CLOSE_BRACE665=null;
 22860  106
         SparqlParser.expression_return expression630 =null;
 22861  
 
 22862  106
         SparqlParser.expression_return expression635 =null;
 22863  
 
 22864  106
         SparqlParser.expression_return expression640 =null;
 22865  
 
 22866  106
         SparqlParser.expression_return expression645 =null;
 22867  
 
 22868  106
         SparqlParser.expression_return expression650 =null;
 22869  
 
 22870  106
         SparqlParser.expression_return expression655 =null;
 22871  
 
 22872  106
         SparqlParser.expression_return expression660 =null;
 22873  
 
 22874  106
         SparqlParser.string_return string664 =null;
 22875  
 
 22876  
 
 22877  106
         Object COUNT626_tree=null;
 22878  106
         Object OPEN_BRACE627_tree=null;
 22879  106
         Object DISTINCT628_tree=null;
 22880  106
         Object ASTERISK629_tree=null;
 22881  106
         Object CLOSE_BRACE631_tree=null;
 22882  106
         Object SUM632_tree=null;
 22883  106
         Object OPEN_BRACE633_tree=null;
 22884  106
         Object DISTINCT634_tree=null;
 22885  106
         Object CLOSE_BRACE636_tree=null;
 22886  106
         Object MIN637_tree=null;
 22887  106
         Object OPEN_BRACE638_tree=null;
 22888  106
         Object DISTINCT639_tree=null;
 22889  106
         Object CLOSE_BRACE641_tree=null;
 22890  106
         Object MAX642_tree=null;
 22891  106
         Object OPEN_BRACE643_tree=null;
 22892  106
         Object DISTINCT644_tree=null;
 22893  106
         Object CLOSE_BRACE646_tree=null;
 22894  106
         Object AVG647_tree=null;
 22895  106
         Object OPEN_BRACE648_tree=null;
 22896  106
         Object DISTINCT649_tree=null;
 22897  106
         Object CLOSE_BRACE651_tree=null;
 22898  106
         Object SAMPLE652_tree=null;
 22899  106
         Object OPEN_BRACE653_tree=null;
 22900  106
         Object DISTINCT654_tree=null;
 22901  106
         Object CLOSE_BRACE656_tree=null;
 22902  106
         Object GROUP_CONCAT657_tree=null;
 22903  106
         Object OPEN_BRACE658_tree=null;
 22904  106
         Object DISTINCT659_tree=null;
 22905  106
         Object SEMICOLON661_tree=null;
 22906  106
         Object SEPARATOR662_tree=null;
 22907  106
         Object EQUAL663_tree=null;
 22908  106
         Object CLOSE_BRACE665_tree=null;
 22909  106
         RewriteRuleTokenStream stream_SAMPLE=new RewriteRuleTokenStream(adaptor,"token SAMPLE");
 22910  106
         RewriteRuleTokenStream stream_AVG=new RewriteRuleTokenStream(adaptor,"token AVG");
 22911  106
         RewriteRuleTokenStream stream_EQUAL=new RewriteRuleTokenStream(adaptor,"token EQUAL");
 22912  106
         RewriteRuleTokenStream stream_GROUP_CONCAT=new RewriteRuleTokenStream(adaptor,"token GROUP_CONCAT");
 22913  106
         RewriteRuleTokenStream stream_MAX=new RewriteRuleTokenStream(adaptor,"token MAX");
 22914  106
         RewriteRuleTokenStream stream_COUNT=new RewriteRuleTokenStream(adaptor,"token COUNT");
 22915  106
         RewriteRuleTokenStream stream_SEMICOLON=new RewriteRuleTokenStream(adaptor,"token SEMICOLON");
 22916  106
         RewriteRuleTokenStream stream_SEPARATOR=new RewriteRuleTokenStream(adaptor,"token SEPARATOR");
 22917  106
         RewriteRuleTokenStream stream_CLOSE_BRACE=new RewriteRuleTokenStream(adaptor,"token CLOSE_BRACE");
 22918  106
         RewriteRuleTokenStream stream_MIN=new RewriteRuleTokenStream(adaptor,"token MIN");
 22919  106
         RewriteRuleTokenStream stream_SUM=new RewriteRuleTokenStream(adaptor,"token SUM");
 22920  106
         RewriteRuleTokenStream stream_DISTINCT=new RewriteRuleTokenStream(adaptor,"token DISTINCT");
 22921  106
         RewriteRuleTokenStream stream_OPEN_BRACE=new RewriteRuleTokenStream(adaptor,"token OPEN_BRACE");
 22922  106
         RewriteRuleTokenStream stream_ASTERISK=new RewriteRuleTokenStream(adaptor,"token ASTERISK");
 22923  106
         RewriteRuleSubtreeStream stream_expression=new RewriteRuleSubtreeStream(adaptor,"rule expression");
 22924  106
         RewriteRuleSubtreeStream stream_string=new RewriteRuleSubtreeStream(adaptor,"rule string");
 22925  
         try {
 22926  
             // com\\googlecode\\sparkleg\\Sparql.g:618:5: ( COUNT OPEN_BRACE ( DISTINCT )? ( ASTERISK | expression ) CLOSE_BRACE -> ^( COUNT ( DISTINCT )* ( ASTERISK )* ( expression )* ) | SUM OPEN_BRACE ( DISTINCT )? expression CLOSE_BRACE -> ^( SUM ( DISTINCT )* expression ) | MIN OPEN_BRACE ( DISTINCT )? expression CLOSE_BRACE -> ^( MIN ( DISTINCT )* expression ) | MAX OPEN_BRACE ( DISTINCT )? expression CLOSE_BRACE -> ^( MAX ( DISTINCT )* expression ) | AVG OPEN_BRACE ( DISTINCT )? expression CLOSE_BRACE -> ^( AVG ( DISTINCT )* expression ) | SAMPLE OPEN_BRACE ( DISTINCT )? expression CLOSE_BRACE -> ^( SAMPLE ( DISTINCT )? expression ) | GROUP_CONCAT OPEN_BRACE ( DISTINCT )? expression ( SEMICOLON SEPARATOR EQUAL string )? CLOSE_BRACE -> ^( GROUP_CONCAT ( DISTINCT )* expression ( string )* ) )
 22927  106
             int alt138=7;
 22928  106
             switch ( input.LA(1) ) {
 22929  
             case COUNT:
 22930  
                 {
 22931  34
                 alt138=1;
 22932  
                 }
 22933  34
                 break;
 22934  
             case SUM:
 22935  
                 {
 22936  12
                 alt138=2;
 22937  
                 }
 22938  12
                 break;
 22939  
             case MIN:
 22940  
                 {
 22941  14
                 alt138=3;
 22942  
                 }
 22943  14
                 break;
 22944  
             case MAX:
 22945  
                 {
 22946  10
                 alt138=4;
 22947  
                 }
 22948  10
                 break;
 22949  
             case AVG:
 22950  
                 {
 22951  24
                 alt138=5;
 22952  
                 }
 22953  24
                 break;
 22954  
             case SAMPLE:
 22955  
                 {
 22956  6
                 alt138=6;
 22957  
                 }
 22958  6
                 break;
 22959  
             case GROUP_CONCAT:
 22960  
                 {
 22961  6
                 alt138=7;
 22962  
                 }
 22963  6
                 break;
 22964  
             default:
 22965  0
                 NoViableAltException nvae =
 22966  
                     new NoViableAltException("", 138, 0, input);
 22967  
 
 22968  0
                 throw nvae;
 22969  
 
 22970  
             }
 22971  
 
 22972  106
             switch (alt138) {
 22973  
                 case 1 :
 22974  
                     // com\\googlecode\\sparkleg\\Sparql.g:618:7: COUNT OPEN_BRACE ( DISTINCT )? ( ASTERISK | expression ) CLOSE_BRACE
 22975  
                     {
 22976  34
                     COUNT626=(Token)match(input,COUNT,FOLLOW_COUNT_in_aggregate6413);  
 22977  34
                     stream_COUNT.add(COUNT626);
 22978  
 
 22979  
 
 22980  34
                     OPEN_BRACE627=(Token)match(input,OPEN_BRACE,FOLLOW_OPEN_BRACE_in_aggregate6415);  
 22981  34
                     stream_OPEN_BRACE.add(OPEN_BRACE627);
 22982  
 
 22983  
 
 22984  
                     // com\\googlecode\\sparkleg\\Sparql.g:618:24: ( DISTINCT )?
 22985  34
                     int alt129=2;
 22986  34
                     switch ( input.LA(1) ) {
 22987  
                         case DISTINCT:
 22988  
                             {
 22989  0
                             alt129=1;
 22990  
                             }
 22991  
                             break;
 22992  
                     }
 22993  
 
 22994  34
                     switch (alt129) {
 22995  
                         case 1 :
 22996  
                             // com\\googlecode\\sparkleg\\Sparql.g:618:24: DISTINCT
 22997  
                             {
 22998  0
                             DISTINCT628=(Token)match(input,DISTINCT,FOLLOW_DISTINCT_in_aggregate6417);  
 22999  0
                             stream_DISTINCT.add(DISTINCT628);
 23000  
 
 23001  
 
 23002  
                             }
 23003  
                             break;
 23004  
 
 23005  
                     }
 23006  
 
 23007  
 
 23008  
                     // com\\googlecode\\sparkleg\\Sparql.g:618:34: ( ASTERISK | expression )
 23009  34
                     int alt130=2;
 23010  34
                     switch ( input.LA(1) ) {
 23011  
                     case ASTERISK:
 23012  
                         {
 23013  14
                         alt130=1;
 23014  
                         }
 23015  14
                         break;
 23016  
                     case ABS:
 23017  
                     case AVG:
 23018  
                     case BNODE:
 23019  
                     case BOUND:
 23020  
                     case CEIL:
 23021  
                     case COALESCE:
 23022  
                     case CONCAT:
 23023  
                     case CONTAINS:
 23024  
                     case COUNT:
 23025  
                     case DATATYPE:
 23026  
                     case DAY:
 23027  
                     case DECIMAL:
 23028  
                     case DECIMAL_NEGATIVE:
 23029  
                     case DECIMAL_POSITIVE:
 23030  
                     case DOUBLE:
 23031  
                     case DOUBLE_NEGATIVE:
 23032  
                     case DOUBLE_POSITIVE:
 23033  
                     case ENCODE_FOR_URI:
 23034  
                     case EXISTS:
 23035  
                     case FALSE:
 23036  
                     case FLOOR:
 23037  
                     case GROUP_CONCAT:
 23038  
                     case HOURS:
 23039  
                     case IF:
 23040  
                     case INTEGER:
 23041  
                     case INTEGER_NEGATIVE:
 23042  
                     case INTEGER_POSITIVE:
 23043  
                     case IRI:
 23044  
                     case IRI_REF:
 23045  
                     case ISBLANK:
 23046  
                     case ISIRI:
 23047  
                     case ISLITERAL:
 23048  
                     case ISNUMERIC:
 23049  
                     case ISURI:
 23050  
                     case LANG:
 23051  
                     case LANGMATCHES:
 23052  
                     case LCASE:
 23053  
                     case MAX:
 23054  
                     case MD5:
 23055  
                     case MIN:
 23056  
                     case MINUS:
 23057  
                     case MINUTES:
 23058  
                     case MONTH:
 23059  
                     case NEGATION:
 23060  
                     case NOT:
 23061  
                     case NOW:
 23062  
                     case OPEN_BRACE:
 23063  
                     case PLUS:
 23064  
                     case PNAME_LN:
 23065  
                     case PNAME_NS:
 23066  
                     case RAND:
 23067  
                     case REGEX:
 23068  
                     case REPLACE:
 23069  
                     case ROUND:
 23070  
                     case SAMETERM:
 23071  
                     case SAMPLE:
 23072  
                     case SECONDS:
 23073  
                     case SHA1:
 23074  
                     case SHA224:
 23075  
                     case SHA256:
 23076  
                     case SHA384:
 23077  
                     case SHA512:
 23078  
                     case STR:
 23079  
                     case STRAFTER:
 23080  
                     case STRBEFORE:
 23081  
                     case STRDT:
 23082  
                     case STRENDS:
 23083  
                     case STRING_LITERAL1:
 23084  
                     case STRING_LITERAL2:
 23085  
                     case STRING_LITERAL_LONG1:
 23086  
                     case STRING_LITERAL_LONG2:
 23087  
                     case STRLANG:
 23088  
                     case STRLEN:
 23089  
                     case STRSTARTS:
 23090  
                     case SUBSTR:
 23091  
                     case SUM:
 23092  
                     case TIMEZONE:
 23093  
                     case TRUE:
 23094  
                     case TZ:
 23095  
                     case UCASE:
 23096  
                     case URI:
 23097  
                     case VAR1:
 23098  
                     case VAR2:
 23099  
                     case YEAR:
 23100  
                         {
 23101  20
                         alt130=2;
 23102  
                         }
 23103  20
                         break;
 23104  
                     default:
 23105  0
                         NoViableAltException nvae =
 23106  
                             new NoViableAltException("", 130, 0, input);
 23107  
 
 23108  0
                         throw nvae;
 23109  
 
 23110  
                     }
 23111  
 
 23112  34
                     switch (alt130) {
 23113  
                         case 1 :
 23114  
                             // com\\googlecode\\sparkleg\\Sparql.g:618:35: ASTERISK
 23115  
                             {
 23116  14
                             ASTERISK629=(Token)match(input,ASTERISK,FOLLOW_ASTERISK_in_aggregate6421);  
 23117  14
                             stream_ASTERISK.add(ASTERISK629);
 23118  
 
 23119  
 
 23120  
                             }
 23121  14
                             break;
 23122  
                         case 2 :
 23123  
                             // com\\googlecode\\sparkleg\\Sparql.g:618:46: expression
 23124  
                             {
 23125  20
                             pushFollow(FOLLOW_expression_in_aggregate6425);
 23126  20
                             expression630=expression();
 23127  
 
 23128  20
                             state._fsp--;
 23129  
 
 23130  20
                             stream_expression.add(expression630.getTree());
 23131  
 
 23132  
                             }
 23133  
                             break;
 23134  
 
 23135  
                     }
 23136  
 
 23137  
 
 23138  34
                     CLOSE_BRACE631=(Token)match(input,CLOSE_BRACE,FOLLOW_CLOSE_BRACE_in_aggregate6428);  
 23139  34
                     stream_CLOSE_BRACE.add(CLOSE_BRACE631);
 23140  
 
 23141  
 
 23142  
                     // AST REWRITE
 23143  
                     // elements: ASTERISK, DISTINCT, COUNT, expression
 23144  
                     // token labels: 
 23145  
                     // rule labels: retval
 23146  
                     // token list labels: 
 23147  
                     // rule list labels: 
 23148  
                     // wildcard labels: 
 23149  34
                     retval.tree = root_0;
 23150  34
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 23151  
 
 23152  34
                     root_0 = (Object)adaptor.nil();
 23153  
                     // 618:70: -> ^( COUNT ( DISTINCT )* ( ASTERISK )* ( expression )* )
 23154  
                     {
 23155  
                         // com\\googlecode\\sparkleg\\Sparql.g:618:73: ^( COUNT ( DISTINCT )* ( ASTERISK )* ( expression )* )
 23156  
                         {
 23157  34
                         Object root_1 = (Object)adaptor.nil();
 23158  34
                         root_1 = (Object)adaptor.becomeRoot(
 23159  
                         stream_COUNT.nextNode()
 23160  
                         , root_1);
 23161  
 
 23162  
                         // com\\googlecode\\sparkleg\\Sparql.g:618:81: ( DISTINCT )*
 23163  34
                         while ( stream_DISTINCT.hasNext() ) {
 23164  0
                             adaptor.addChild(root_1, 
 23165  
                             stream_DISTINCT.nextNode()
 23166  
                             );
 23167  
 
 23168  
                         }
 23169  34
                         stream_DISTINCT.reset();
 23170  
 
 23171  
                         // com\\googlecode\\sparkleg\\Sparql.g:618:91: ( ASTERISK )*
 23172  48
                         while ( stream_ASTERISK.hasNext() ) {
 23173  14
                             adaptor.addChild(root_1, 
 23174  
                             stream_ASTERISK.nextNode()
 23175  
                             );
 23176  
 
 23177  
                         }
 23178  34
                         stream_ASTERISK.reset();
 23179  
 
 23180  
                         // com\\googlecode\\sparkleg\\Sparql.g:618:101: ( expression )*
 23181  54
                         while ( stream_expression.hasNext() ) {
 23182  20
                             adaptor.addChild(root_1, stream_expression.nextTree());
 23183  
 
 23184  
                         }
 23185  34
                         stream_expression.reset();
 23186  
 
 23187  34
                         adaptor.addChild(root_0, root_1);
 23188  
                         }
 23189  
 
 23190  
                     }
 23191  
 
 23192  
 
 23193  34
                     retval.tree = root_0;
 23194  
 
 23195  
                     }
 23196  34
                     break;
 23197  
                 case 2 :
 23198  
                     // com\\googlecode\\sparkleg\\Sparql.g:619:7: SUM OPEN_BRACE ( DISTINCT )? expression CLOSE_BRACE
 23199  
                     {
 23200  12
                     SUM632=(Token)match(input,SUM,FOLLOW_SUM_in_aggregate6451);  
 23201  12
                     stream_SUM.add(SUM632);
 23202  
 
 23203  
 
 23204  12
                     OPEN_BRACE633=(Token)match(input,OPEN_BRACE,FOLLOW_OPEN_BRACE_in_aggregate6453);  
 23205  12
                     stream_OPEN_BRACE.add(OPEN_BRACE633);
 23206  
 
 23207  
 
 23208  
                     // com\\googlecode\\sparkleg\\Sparql.g:619:22: ( DISTINCT )?
 23209  12
                     int alt131=2;
 23210  12
                     switch ( input.LA(1) ) {
 23211  
                         case DISTINCT:
 23212  
                             {
 23213  0
                             alt131=1;
 23214  
                             }
 23215  
                             break;
 23216  
                     }
 23217  
 
 23218  12
                     switch (alt131) {
 23219  
                         case 1 :
 23220  
                             // com\\googlecode\\sparkleg\\Sparql.g:619:22: DISTINCT
 23221  
                             {
 23222  0
                             DISTINCT634=(Token)match(input,DISTINCT,FOLLOW_DISTINCT_in_aggregate6455);  
 23223  0
                             stream_DISTINCT.add(DISTINCT634);
 23224  
 
 23225  
 
 23226  
                             }
 23227  
                             break;
 23228  
 
 23229  
                     }
 23230  
 
 23231  
 
 23232  12
                     pushFollow(FOLLOW_expression_in_aggregate6458);
 23233  12
                     expression635=expression();
 23234  
 
 23235  12
                     state._fsp--;
 23236  
 
 23237  12
                     stream_expression.add(expression635.getTree());
 23238  
 
 23239  12
                     CLOSE_BRACE636=(Token)match(input,CLOSE_BRACE,FOLLOW_CLOSE_BRACE_in_aggregate6460);  
 23240  12
                     stream_CLOSE_BRACE.add(CLOSE_BRACE636);
 23241  
 
 23242  
 
 23243  
                     // AST REWRITE
 23244  
                     // elements: expression, SUM, DISTINCT
 23245  
                     // token labels: 
 23246  
                     // rule labels: retval
 23247  
                     // token list labels: 
 23248  
                     // rule list labels: 
 23249  
                     // wildcard labels: 
 23250  12
                     retval.tree = root_0;
 23251  12
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 23252  
 
 23253  12
                     root_0 = (Object)adaptor.nil();
 23254  
                     // 619:55: -> ^( SUM ( DISTINCT )* expression )
 23255  
                     {
 23256  
                         // com\\googlecode\\sparkleg\\Sparql.g:619:58: ^( SUM ( DISTINCT )* expression )
 23257  
                         {
 23258  12
                         Object root_1 = (Object)adaptor.nil();
 23259  12
                         root_1 = (Object)adaptor.becomeRoot(
 23260  
                         stream_SUM.nextNode()
 23261  
                         , root_1);
 23262  
 
 23263  
                         // com\\googlecode\\sparkleg\\Sparql.g:619:64: ( DISTINCT )*
 23264  12
                         while ( stream_DISTINCT.hasNext() ) {
 23265  0
                             adaptor.addChild(root_1, 
 23266  
                             stream_DISTINCT.nextNode()
 23267  
                             );
 23268  
 
 23269  
                         }
 23270  12
                         stream_DISTINCT.reset();
 23271  
 
 23272  12
                         adaptor.addChild(root_1, stream_expression.nextTree());
 23273  
 
 23274  12
                         adaptor.addChild(root_0, root_1);
 23275  
                         }
 23276  
 
 23277  
                     }
 23278  
 
 23279  
 
 23280  12
                     retval.tree = root_0;
 23281  
 
 23282  
                     }
 23283  12
                     break;
 23284  
                 case 3 :
 23285  
                     // com\\googlecode\\sparkleg\\Sparql.g:620:7: MIN OPEN_BRACE ( DISTINCT )? expression CLOSE_BRACE
 23286  
                     {
 23287  14
                     MIN637=(Token)match(input,MIN,FOLLOW_MIN_in_aggregate6479);  
 23288  14
                     stream_MIN.add(MIN637);
 23289  
 
 23290  
 
 23291  14
                     OPEN_BRACE638=(Token)match(input,OPEN_BRACE,FOLLOW_OPEN_BRACE_in_aggregate6481);  
 23292  14
                     stream_OPEN_BRACE.add(OPEN_BRACE638);
 23293  
 
 23294  
 
 23295  
                     // com\\googlecode\\sparkleg\\Sparql.g:620:22: ( DISTINCT )?
 23296  14
                     int alt132=2;
 23297  14
                     switch ( input.LA(1) ) {
 23298  
                         case DISTINCT:
 23299  
                             {
 23300  0
                             alt132=1;
 23301  
                             }
 23302  
                             break;
 23303  
                     }
 23304  
 
 23305  14
                     switch (alt132) {
 23306  
                         case 1 :
 23307  
                             // com\\googlecode\\sparkleg\\Sparql.g:620:22: DISTINCT
 23308  
                             {
 23309  0
                             DISTINCT639=(Token)match(input,DISTINCT,FOLLOW_DISTINCT_in_aggregate6483);  
 23310  0
                             stream_DISTINCT.add(DISTINCT639);
 23311  
 
 23312  
 
 23313  
                             }
 23314  
                             break;
 23315  
 
 23316  
                     }
 23317  
 
 23318  
 
 23319  14
                     pushFollow(FOLLOW_expression_in_aggregate6486);
 23320  14
                     expression640=expression();
 23321  
 
 23322  14
                     state._fsp--;
 23323  
 
 23324  14
                     stream_expression.add(expression640.getTree());
 23325  
 
 23326  14
                     CLOSE_BRACE641=(Token)match(input,CLOSE_BRACE,FOLLOW_CLOSE_BRACE_in_aggregate6488);  
 23327  14
                     stream_CLOSE_BRACE.add(CLOSE_BRACE641);
 23328  
 
 23329  
 
 23330  
                     // AST REWRITE
 23331  
                     // elements: expression, MIN, DISTINCT
 23332  
                     // token labels: 
 23333  
                     // rule labels: retval
 23334  
                     // token list labels: 
 23335  
                     // rule list labels: 
 23336  
                     // wildcard labels: 
 23337  14
                     retval.tree = root_0;
 23338  14
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 23339  
 
 23340  14
                     root_0 = (Object)adaptor.nil();
 23341  
                     // 620:55: -> ^( MIN ( DISTINCT )* expression )
 23342  
                     {
 23343  
                         // com\\googlecode\\sparkleg\\Sparql.g:620:58: ^( MIN ( DISTINCT )* expression )
 23344  
                         {
 23345  14
                         Object root_1 = (Object)adaptor.nil();
 23346  14
                         root_1 = (Object)adaptor.becomeRoot(
 23347  
                         stream_MIN.nextNode()
 23348  
                         , root_1);
 23349  
 
 23350  
                         // com\\googlecode\\sparkleg\\Sparql.g:620:64: ( DISTINCT )*
 23351  14
                         while ( stream_DISTINCT.hasNext() ) {
 23352  0
                             adaptor.addChild(root_1, 
 23353  
                             stream_DISTINCT.nextNode()
 23354  
                             );
 23355  
 
 23356  
                         }
 23357  14
                         stream_DISTINCT.reset();
 23358  
 
 23359  14
                         adaptor.addChild(root_1, stream_expression.nextTree());
 23360  
 
 23361  14
                         adaptor.addChild(root_0, root_1);
 23362  
                         }
 23363  
 
 23364  
                     }
 23365  
 
 23366  
 
 23367  14
                     retval.tree = root_0;
 23368  
 
 23369  
                     }
 23370  14
                     break;
 23371  
                 case 4 :
 23372  
                     // com\\googlecode\\sparkleg\\Sparql.g:621:7: MAX OPEN_BRACE ( DISTINCT )? expression CLOSE_BRACE
 23373  
                     {
 23374  10
                     MAX642=(Token)match(input,MAX,FOLLOW_MAX_in_aggregate6507);  
 23375  10
                     stream_MAX.add(MAX642);
 23376  
 
 23377  
 
 23378  10
                     OPEN_BRACE643=(Token)match(input,OPEN_BRACE,FOLLOW_OPEN_BRACE_in_aggregate6509);  
 23379  10
                     stream_OPEN_BRACE.add(OPEN_BRACE643);
 23380  
 
 23381  
 
 23382  
                     // com\\googlecode\\sparkleg\\Sparql.g:621:22: ( DISTINCT )?
 23383  10
                     int alt133=2;
 23384  10
                     switch ( input.LA(1) ) {
 23385  
                         case DISTINCT:
 23386  
                             {
 23387  0
                             alt133=1;
 23388  
                             }
 23389  
                             break;
 23390  
                     }
 23391  
 
 23392  10
                     switch (alt133) {
 23393  
                         case 1 :
 23394  
                             // com\\googlecode\\sparkleg\\Sparql.g:621:22: DISTINCT
 23395  
                             {
 23396  0
                             DISTINCT644=(Token)match(input,DISTINCT,FOLLOW_DISTINCT_in_aggregate6511);  
 23397  0
                             stream_DISTINCT.add(DISTINCT644);
 23398  
 
 23399  
 
 23400  
                             }
 23401  
                             break;
 23402  
 
 23403  
                     }
 23404  
 
 23405  
 
 23406  10
                     pushFollow(FOLLOW_expression_in_aggregate6514);
 23407  10
                     expression645=expression();
 23408  
 
 23409  10
                     state._fsp--;
 23410  
 
 23411  10
                     stream_expression.add(expression645.getTree());
 23412  
 
 23413  10
                     CLOSE_BRACE646=(Token)match(input,CLOSE_BRACE,FOLLOW_CLOSE_BRACE_in_aggregate6516);  
 23414  10
                     stream_CLOSE_BRACE.add(CLOSE_BRACE646);
 23415  
 
 23416  
 
 23417  
                     // AST REWRITE
 23418  
                     // elements: DISTINCT, MAX, expression
 23419  
                     // token labels: 
 23420  
                     // rule labels: retval
 23421  
                     // token list labels: 
 23422  
                     // rule list labels: 
 23423  
                     // wildcard labels: 
 23424  10
                     retval.tree = root_0;
 23425  10
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 23426  
 
 23427  10
                     root_0 = (Object)adaptor.nil();
 23428  
                     // 621:55: -> ^( MAX ( DISTINCT )* expression )
 23429  
                     {
 23430  
                         // com\\googlecode\\sparkleg\\Sparql.g:621:58: ^( MAX ( DISTINCT )* expression )
 23431  
                         {
 23432  10
                         Object root_1 = (Object)adaptor.nil();
 23433  10
                         root_1 = (Object)adaptor.becomeRoot(
 23434  
                         stream_MAX.nextNode()
 23435  
                         , root_1);
 23436  
 
 23437  
                         // com\\googlecode\\sparkleg\\Sparql.g:621:64: ( DISTINCT )*
 23438  10
                         while ( stream_DISTINCT.hasNext() ) {
 23439  0
                             adaptor.addChild(root_1, 
 23440  
                             stream_DISTINCT.nextNode()
 23441  
                             );
 23442  
 
 23443  
                         }
 23444  10
                         stream_DISTINCT.reset();
 23445  
 
 23446  10
                         adaptor.addChild(root_1, stream_expression.nextTree());
 23447  
 
 23448  10
                         adaptor.addChild(root_0, root_1);
 23449  
                         }
 23450  
 
 23451  
                     }
 23452  
 
 23453  
 
 23454  10
                     retval.tree = root_0;
 23455  
 
 23456  
                     }
 23457  10
                     break;
 23458  
                 case 5 :
 23459  
                     // com\\googlecode\\sparkleg\\Sparql.g:622:7: AVG OPEN_BRACE ( DISTINCT )? expression CLOSE_BRACE
 23460  
                     {
 23461  24
                     AVG647=(Token)match(input,AVG,FOLLOW_AVG_in_aggregate6535);  
 23462  24
                     stream_AVG.add(AVG647);
 23463  
 
 23464  
 
 23465  24
                     OPEN_BRACE648=(Token)match(input,OPEN_BRACE,FOLLOW_OPEN_BRACE_in_aggregate6537);  
 23466  24
                     stream_OPEN_BRACE.add(OPEN_BRACE648);
 23467  
 
 23468  
 
 23469  
                     // com\\googlecode\\sparkleg\\Sparql.g:622:22: ( DISTINCT )?
 23470  24
                     int alt134=2;
 23471  24
                     switch ( input.LA(1) ) {
 23472  
                         case DISTINCT:
 23473  
                             {
 23474  0
                             alt134=1;
 23475  
                             }
 23476  
                             break;
 23477  
                     }
 23478  
 
 23479  24
                     switch (alt134) {
 23480  
                         case 1 :
 23481  
                             // com\\googlecode\\sparkleg\\Sparql.g:622:22: DISTINCT
 23482  
                             {
 23483  0
                             DISTINCT649=(Token)match(input,DISTINCT,FOLLOW_DISTINCT_in_aggregate6539);  
 23484  0
                             stream_DISTINCT.add(DISTINCT649);
 23485  
 
 23486  
 
 23487  
                             }
 23488  
                             break;
 23489  
 
 23490  
                     }
 23491  
 
 23492  
 
 23493  24
                     pushFollow(FOLLOW_expression_in_aggregate6542);
 23494  24
                     expression650=expression();
 23495  
 
 23496  24
                     state._fsp--;
 23497  
 
 23498  24
                     stream_expression.add(expression650.getTree());
 23499  
 
 23500  24
                     CLOSE_BRACE651=(Token)match(input,CLOSE_BRACE,FOLLOW_CLOSE_BRACE_in_aggregate6544);  
 23501  24
                     stream_CLOSE_BRACE.add(CLOSE_BRACE651);
 23502  
 
 23503  
 
 23504  
                     // AST REWRITE
 23505  
                     // elements: DISTINCT, expression, AVG
 23506  
                     // token labels: 
 23507  
                     // rule labels: retval
 23508  
                     // token list labels: 
 23509  
                     // rule list labels: 
 23510  
                     // wildcard labels: 
 23511  24
                     retval.tree = root_0;
 23512  24
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 23513  
 
 23514  24
                     root_0 = (Object)adaptor.nil();
 23515  
                     // 622:55: -> ^( AVG ( DISTINCT )* expression )
 23516  
                     {
 23517  
                         // com\\googlecode\\sparkleg\\Sparql.g:622:58: ^( AVG ( DISTINCT )* expression )
 23518  
                         {
 23519  24
                         Object root_1 = (Object)adaptor.nil();
 23520  24
                         root_1 = (Object)adaptor.becomeRoot(
 23521  
                         stream_AVG.nextNode()
 23522  
                         , root_1);
 23523  
 
 23524  
                         // com\\googlecode\\sparkleg\\Sparql.g:622:64: ( DISTINCT )*
 23525  24
                         while ( stream_DISTINCT.hasNext() ) {
 23526  0
                             adaptor.addChild(root_1, 
 23527  
                             stream_DISTINCT.nextNode()
 23528  
                             );
 23529  
 
 23530  
                         }
 23531  24
                         stream_DISTINCT.reset();
 23532  
 
 23533  24
                         adaptor.addChild(root_1, stream_expression.nextTree());
 23534  
 
 23535  24
                         adaptor.addChild(root_0, root_1);
 23536  
                         }
 23537  
 
 23538  
                     }
 23539  
 
 23540  
 
 23541  24
                     retval.tree = root_0;
 23542  
 
 23543  
                     }
 23544  24
                     break;
 23545  
                 case 6 :
 23546  
                     // com\\googlecode\\sparkleg\\Sparql.g:623:7: SAMPLE OPEN_BRACE ( DISTINCT )? expression CLOSE_BRACE
 23547  
                     {
 23548  6
                     SAMPLE652=(Token)match(input,SAMPLE,FOLLOW_SAMPLE_in_aggregate6563);  
 23549  6
                     stream_SAMPLE.add(SAMPLE652);
 23550  
 
 23551  
 
 23552  6
                     OPEN_BRACE653=(Token)match(input,OPEN_BRACE,FOLLOW_OPEN_BRACE_in_aggregate6565);  
 23553  6
                     stream_OPEN_BRACE.add(OPEN_BRACE653);
 23554  
 
 23555  
 
 23556  
                     // com\\googlecode\\sparkleg\\Sparql.g:623:25: ( DISTINCT )?
 23557  6
                     int alt135=2;
 23558  6
                     switch ( input.LA(1) ) {
 23559  
                         case DISTINCT:
 23560  
                             {
 23561  0
                             alt135=1;
 23562  
                             }
 23563  
                             break;
 23564  
                     }
 23565  
 
 23566  6
                     switch (alt135) {
 23567  
                         case 1 :
 23568  
                             // com\\googlecode\\sparkleg\\Sparql.g:623:25: DISTINCT
 23569  
                             {
 23570  0
                             DISTINCT654=(Token)match(input,DISTINCT,FOLLOW_DISTINCT_in_aggregate6567);  
 23571  0
                             stream_DISTINCT.add(DISTINCT654);
 23572  
 
 23573  
 
 23574  
                             }
 23575  
                             break;
 23576  
 
 23577  
                     }
 23578  
 
 23579  
 
 23580  6
                     pushFollow(FOLLOW_expression_in_aggregate6570);
 23581  6
                     expression655=expression();
 23582  
 
 23583  6
                     state._fsp--;
 23584  
 
 23585  6
                     stream_expression.add(expression655.getTree());
 23586  
 
 23587  6
                     CLOSE_BRACE656=(Token)match(input,CLOSE_BRACE,FOLLOW_CLOSE_BRACE_in_aggregate6572);  
 23588  6
                     stream_CLOSE_BRACE.add(CLOSE_BRACE656);
 23589  
 
 23590  
 
 23591  
                     // AST REWRITE
 23592  
                     // elements: SAMPLE, DISTINCT, expression
 23593  
                     // token labels: 
 23594  
                     // rule labels: retval
 23595  
                     // token list labels: 
 23596  
                     // rule list labels: 
 23597  
                     // wildcard labels: 
 23598  6
                     retval.tree = root_0;
 23599  6
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 23600  
 
 23601  6
                     root_0 = (Object)adaptor.nil();
 23602  
                     // 623:58: -> ^( SAMPLE ( DISTINCT )? expression )
 23603  
                     {
 23604  
                         // com\\googlecode\\sparkleg\\Sparql.g:623:61: ^( SAMPLE ( DISTINCT )? expression )
 23605  
                         {
 23606  6
                         Object root_1 = (Object)adaptor.nil();
 23607  6
                         root_1 = (Object)adaptor.becomeRoot(
 23608  
                         stream_SAMPLE.nextNode()
 23609  
                         , root_1);
 23610  
 
 23611  
                         // com\\googlecode\\sparkleg\\Sparql.g:623:70: ( DISTINCT )?
 23612  6
                         if ( stream_DISTINCT.hasNext() ) {
 23613  0
                             adaptor.addChild(root_1, 
 23614  
                             stream_DISTINCT.nextNode()
 23615  
                             );
 23616  
 
 23617  
                         }
 23618  6
                         stream_DISTINCT.reset();
 23619  
 
 23620  6
                         adaptor.addChild(root_1, stream_expression.nextTree());
 23621  
 
 23622  6
                         adaptor.addChild(root_0, root_1);
 23623  
                         }
 23624  
 
 23625  
                     }
 23626  
 
 23627  
 
 23628  6
                     retval.tree = root_0;
 23629  
 
 23630  
                     }
 23631  6
                     break;
 23632  
                 case 7 :
 23633  
                     // com\\googlecode\\sparkleg\\Sparql.g:624:7: GROUP_CONCAT OPEN_BRACE ( DISTINCT )? expression ( SEMICOLON SEPARATOR EQUAL string )? CLOSE_BRACE
 23634  
                     {
 23635  6
                     GROUP_CONCAT657=(Token)match(input,GROUP_CONCAT,FOLLOW_GROUP_CONCAT_in_aggregate6591);  
 23636  6
                     stream_GROUP_CONCAT.add(GROUP_CONCAT657);
 23637  
 
 23638  
 
 23639  6
                     OPEN_BRACE658=(Token)match(input,OPEN_BRACE,FOLLOW_OPEN_BRACE_in_aggregate6593);  
 23640  6
                     stream_OPEN_BRACE.add(OPEN_BRACE658);
 23641  
 
 23642  
 
 23643  
                     // com\\googlecode\\sparkleg\\Sparql.g:624:31: ( DISTINCT )?
 23644  6
                     int alt136=2;
 23645  6
                     switch ( input.LA(1) ) {
 23646  
                         case DISTINCT:
 23647  
                             {
 23648  0
                             alt136=1;
 23649  
                             }
 23650  
                             break;
 23651  
                     }
 23652  
 
 23653  6
                     switch (alt136) {
 23654  
                         case 1 :
 23655  
                             // com\\googlecode\\sparkleg\\Sparql.g:624:31: DISTINCT
 23656  
                             {
 23657  0
                             DISTINCT659=(Token)match(input,DISTINCT,FOLLOW_DISTINCT_in_aggregate6595);  
 23658  0
                             stream_DISTINCT.add(DISTINCT659);
 23659  
 
 23660  
 
 23661  
                             }
 23662  
                             break;
 23663  
 
 23664  
                     }
 23665  
 
 23666  
 
 23667  6
                     pushFollow(FOLLOW_expression_in_aggregate6598);
 23668  6
                     expression660=expression();
 23669  
 
 23670  6
                     state._fsp--;
 23671  
 
 23672  6
                     stream_expression.add(expression660.getTree());
 23673  
 
 23674  
                     // com\\googlecode\\sparkleg\\Sparql.g:624:52: ( SEMICOLON SEPARATOR EQUAL string )?
 23675  6
                     int alt137=2;
 23676  6
                     switch ( input.LA(1) ) {
 23677  
                         case SEMICOLON:
 23678  
                             {
 23679  2
                             alt137=1;
 23680  
                             }
 23681  
                             break;
 23682  
                     }
 23683  
 
 23684  6
                     switch (alt137) {
 23685  
                         case 1 :
 23686  
                             // com\\googlecode\\sparkleg\\Sparql.g:624:53: SEMICOLON SEPARATOR EQUAL string
 23687  
                             {
 23688  2
                             SEMICOLON661=(Token)match(input,SEMICOLON,FOLLOW_SEMICOLON_in_aggregate6601);  
 23689  2
                             stream_SEMICOLON.add(SEMICOLON661);
 23690  
 
 23691  
 
 23692  2
                             SEPARATOR662=(Token)match(input,SEPARATOR,FOLLOW_SEPARATOR_in_aggregate6603);  
 23693  2
                             stream_SEPARATOR.add(SEPARATOR662);
 23694  
 
 23695  
 
 23696  2
                             EQUAL663=(Token)match(input,EQUAL,FOLLOW_EQUAL_in_aggregate6605);  
 23697  2
                             stream_EQUAL.add(EQUAL663);
 23698  
 
 23699  
 
 23700  2
                             pushFollow(FOLLOW_string_in_aggregate6607);
 23701  2
                             string664=string();
 23702  
 
 23703  2
                             state._fsp--;
 23704  
 
 23705  2
                             stream_string.add(string664.getTree());
 23706  
 
 23707  
                             }
 23708  
                             break;
 23709  
 
 23710  
                     }
 23711  
 
 23712  
 
 23713  6
                     CLOSE_BRACE665=(Token)match(input,CLOSE_BRACE,FOLLOW_CLOSE_BRACE_in_aggregate6611);  
 23714  6
                     stream_CLOSE_BRACE.add(CLOSE_BRACE665);
 23715  
 
 23716  
 
 23717  
                     // AST REWRITE
 23718  
                     // elements: expression, GROUP_CONCAT, DISTINCT, string
 23719  
                     // token labels: 
 23720  
                     // rule labels: retval
 23721  
                     // token list labels: 
 23722  
                     // rule list labels: 
 23723  
                     // wildcard labels: 
 23724  6
                     retval.tree = root_0;
 23725  6
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 23726  
 
 23727  6
                     root_0 = (Object)adaptor.nil();
 23728  
                     // 624:100: -> ^( GROUP_CONCAT ( DISTINCT )* expression ( string )* )
 23729  
                     {
 23730  
                         // com\\googlecode\\sparkleg\\Sparql.g:624:103: ^( GROUP_CONCAT ( DISTINCT )* expression ( string )* )
 23731  
                         {
 23732  6
                         Object root_1 = (Object)adaptor.nil();
 23733  6
                         root_1 = (Object)adaptor.becomeRoot(
 23734  
                         stream_GROUP_CONCAT.nextNode()
 23735  
                         , root_1);
 23736  
 
 23737  
                         // com\\googlecode\\sparkleg\\Sparql.g:624:118: ( DISTINCT )*
 23738  6
                         while ( stream_DISTINCT.hasNext() ) {
 23739  0
                             adaptor.addChild(root_1, 
 23740  
                             stream_DISTINCT.nextNode()
 23741  
                             );
 23742  
 
 23743  
                         }
 23744  6
                         stream_DISTINCT.reset();
 23745  
 
 23746  6
                         adaptor.addChild(root_1, stream_expression.nextTree());
 23747  
 
 23748  
                         // com\\googlecode\\sparkleg\\Sparql.g:624:139: ( string )*
 23749  8
                         while ( stream_string.hasNext() ) {
 23750  2
                             adaptor.addChild(root_1, stream_string.nextTree());
 23751  
 
 23752  
                         }
 23753  6
                         stream_string.reset();
 23754  
 
 23755  6
                         adaptor.addChild(root_0, root_1);
 23756  
                         }
 23757  
 
 23758  
                     }
 23759  
 
 23760  
 
 23761  6
                     retval.tree = root_0;
 23762  
 
 23763  
                     }
 23764  
                     break;
 23765  
 
 23766  
             }
 23767  106
             retval.stop = input.LT(-1);
 23768  
 
 23769  
 
 23770  106
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 23771  106
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 23772  
 
 23773  
         }
 23774  0
         catch (RecognitionException re) {
 23775  0
             reportError(re);
 23776  0
             recover(input,re);
 23777  0
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 23778  
 
 23779  
         }
 23780  
 
 23781  0
         finally {
 23782  
                 // do for sure before leaving
 23783  106
         }
 23784  106
         return retval;
 23785  
     }
 23786  
     // $ANTLR end "aggregate"
 23787  
 
 23788  
 
 23789  178
     public static class iriRefOrFunction_return extends ParserRuleReturnScope {
 23790  
         Object tree;
 23791  178
         public Object getTree() { return tree; }
 23792  
     };
 23793  
 
 23794  
 
 23795  
     // $ANTLR start "iriRefOrFunction"
 23796  
     // com\\googlecode\\sparkleg\\Sparql.g:627:1: iriRefOrFunction : iriRef ( argList )? -> ^( FUNCTION iriRef ( ^( ARG_LIST argList ) )? ) ;
 23797  
     public final SparqlParser.iriRefOrFunction_return iriRefOrFunction() throws RecognitionException {
 23798  178
         SparqlParser.iriRefOrFunction_return retval = new SparqlParser.iriRefOrFunction_return();
 23799  178
         retval.start = input.LT(1);
 23800  
 
 23801  
 
 23802  178
         Object root_0 = null;
 23803  
 
 23804  178
         SparqlParser.iriRef_return iriRef666 =null;
 23805  
 
 23806  178
         SparqlParser.argList_return argList667 =null;
 23807  
 
 23808  
 
 23809  178
         RewriteRuleSubtreeStream stream_argList=new RewriteRuleSubtreeStream(adaptor,"rule argList");
 23810  178
         RewriteRuleSubtreeStream stream_iriRef=new RewriteRuleSubtreeStream(adaptor,"rule iriRef");
 23811  
         try {
 23812  
             // com\\googlecode\\sparkleg\\Sparql.g:628:5: ( iriRef ( argList )? -> ^( FUNCTION iriRef ( ^( ARG_LIST argList ) )? ) )
 23813  
             // com\\googlecode\\sparkleg\\Sparql.g:628:7: iriRef ( argList )?
 23814  
             {
 23815  178
             pushFollow(FOLLOW_iriRef_in_iriRefOrFunction6646);
 23816  178
             iriRef666=iriRef();
 23817  
 
 23818  178
             state._fsp--;
 23819  
 
 23820  178
             stream_iriRef.add(iriRef666.getTree());
 23821  
 
 23822  
             // com\\googlecode\\sparkleg\\Sparql.g:628:14: ( argList )?
 23823  178
             int alt139=2;
 23824  178
             switch ( input.LA(1) ) {
 23825  
                 case OPEN_BRACE:
 23826  
                     {
 23827  113
                     alt139=1;
 23828  
                     }
 23829  
                     break;
 23830  
             }
 23831  
 
 23832  178
             switch (alt139) {
 23833  
                 case 1 :
 23834  
                     // com\\googlecode\\sparkleg\\Sparql.g:628:14: argList
 23835  
                     {
 23836  113
                     pushFollow(FOLLOW_argList_in_iriRefOrFunction6648);
 23837  113
                     argList667=argList();
 23838  
 
 23839  113
                     state._fsp--;
 23840  
 
 23841  113
                     stream_argList.add(argList667.getTree());
 23842  
 
 23843  
                     }
 23844  
                     break;
 23845  
 
 23846  
             }
 23847  
 
 23848  
 
 23849  
             // AST REWRITE
 23850  
             // elements: iriRef, argList
 23851  
             // token labels: 
 23852  
             // rule labels: retval
 23853  
             // token list labels: 
 23854  
             // rule list labels: 
 23855  
             // wildcard labels: 
 23856  178
             retval.tree = root_0;
 23857  178
             RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 23858  
 
 23859  178
             root_0 = (Object)adaptor.nil();
 23860  
             // 628:23: -> ^( FUNCTION iriRef ( ^( ARG_LIST argList ) )? )
 23861  
             {
 23862  
                 // com\\googlecode\\sparkleg\\Sparql.g:628:26: ^( FUNCTION iriRef ( ^( ARG_LIST argList ) )? )
 23863  
                 {
 23864  178
                 Object root_1 = (Object)adaptor.nil();
 23865  178
                 root_1 = (Object)adaptor.becomeRoot(
 23866  
                 (Object)adaptor.create(FUNCTION, "FUNCTION")
 23867  
                 , root_1);
 23868  
 
 23869  178
                 adaptor.addChild(root_1, stream_iriRef.nextTree());
 23870  
 
 23871  
                 // com\\googlecode\\sparkleg\\Sparql.g:628:44: ( ^( ARG_LIST argList ) )?
 23872  178
                 if ( stream_argList.hasNext() ) {
 23873  
                     // com\\googlecode\\sparkleg\\Sparql.g:628:44: ^( ARG_LIST argList )
 23874  
                     {
 23875  113
                     Object root_2 = (Object)adaptor.nil();
 23876  113
                     root_2 = (Object)adaptor.becomeRoot(
 23877  
                     (Object)adaptor.create(ARG_LIST, "ARG_LIST")
 23878  
                     , root_2);
 23879  
 
 23880  113
                     adaptor.addChild(root_2, stream_argList.nextTree());
 23881  
 
 23882  113
                     adaptor.addChild(root_1, root_2);
 23883  
                     }
 23884  
 
 23885  
                 }
 23886  178
                 stream_argList.reset();
 23887  
 
 23888  178
                 adaptor.addChild(root_0, root_1);
 23889  
                 }
 23890  
 
 23891  
             }
 23892  
 
 23893  
 
 23894  178
             retval.tree = root_0;
 23895  
 
 23896  
             }
 23897  
 
 23898  178
             retval.stop = input.LT(-1);
 23899  
 
 23900  
 
 23901  178
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 23902  178
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 23903  
 
 23904  
         }
 23905  0
         catch (RecognitionException re) {
 23906  0
             reportError(re);
 23907  0
             recover(input,re);
 23908  0
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 23909  
 
 23910  
         }
 23911  
 
 23912  0
         finally {
 23913  
                 // do for sure before leaving
 23914  178
         }
 23915  178
         return retval;
 23916  
     }
 23917  
     // $ANTLR end "iriRefOrFunction"
 23918  
 
 23919  
 
 23920  378
     public static class rdfLiteral_return extends ParserRuleReturnScope {
 23921  
         Object tree;
 23922  378
         public Object getTree() { return tree; }
 23923  
     };
 23924  
 
 23925  
 
 23926  
     // $ANTLR start "rdfLiteral"
 23927  
     // com\\googlecode\\sparkleg\\Sparql.g:631:1: rdfLiteral : string ( LANGTAG | ( REFERENCE iriRef ) )? ;
 23928  
     public final SparqlParser.rdfLiteral_return rdfLiteral() throws RecognitionException {
 23929  378
         SparqlParser.rdfLiteral_return retval = new SparqlParser.rdfLiteral_return();
 23930  378
         retval.start = input.LT(1);
 23931  
 
 23932  
 
 23933  378
         Object root_0 = null;
 23934  
 
 23935  378
         Token LANGTAG669=null;
 23936  378
         Token REFERENCE670=null;
 23937  378
         SparqlParser.string_return string668 =null;
 23938  
 
 23939  378
         SparqlParser.iriRef_return iriRef671 =null;
 23940  
 
 23941  
 
 23942  378
         Object LANGTAG669_tree=null;
 23943  378
         Object REFERENCE670_tree=null;
 23944  
 
 23945  
         try {
 23946  
             // com\\googlecode\\sparkleg\\Sparql.g:632:5: ( string ( LANGTAG | ( REFERENCE iriRef ) )? )
 23947  
             // com\\googlecode\\sparkleg\\Sparql.g:632:7: string ( LANGTAG | ( REFERENCE iriRef ) )?
 23948  
             {
 23949  378
             root_0 = (Object)adaptor.nil();
 23950  
 
 23951  
 
 23952  378
             pushFollow(FOLLOW_string_in_rdfLiteral6681);
 23953  378
             string668=string();
 23954  
 
 23955  378
             state._fsp--;
 23956  
 
 23957  378
             adaptor.addChild(root_0, string668.getTree());
 23958  
 
 23959  
             // com\\googlecode\\sparkleg\\Sparql.g:632:14: ( LANGTAG | ( REFERENCE iriRef ) )?
 23960  378
             int alt140=3;
 23961  378
             switch ( input.LA(1) ) {
 23962  
                 case LANGTAG:
 23963  
                     {
 23964  10
                     alt140=1;
 23965  
                     }
 23966  10
                     break;
 23967  
                 case REFERENCE:
 23968  
                     {
 23969  38
                     alt140=2;
 23970  
                     }
 23971  
                     break;
 23972  
             }
 23973  
 
 23974  378
             switch (alt140) {
 23975  
                 case 1 :
 23976  
                     // com\\googlecode\\sparkleg\\Sparql.g:632:15: LANGTAG
 23977  
                     {
 23978  10
                     LANGTAG669=(Token)match(input,LANGTAG,FOLLOW_LANGTAG_in_rdfLiteral6684); 
 23979  10
                     LANGTAG669_tree = 
 23980  
                     (Object)adaptor.create(LANGTAG669)
 23981  
                     ;
 23982  10
                     adaptor.addChild(root_0, LANGTAG669_tree);
 23983  
 
 23984  
 
 23985  
                     }
 23986  10
                     break;
 23987  
                 case 2 :
 23988  
                     // com\\googlecode\\sparkleg\\Sparql.g:632:25: ( REFERENCE iriRef )
 23989  
                     {
 23990  
                     // com\\googlecode\\sparkleg\\Sparql.g:632:25: ( REFERENCE iriRef )
 23991  
                     // com\\googlecode\\sparkleg\\Sparql.g:632:26: REFERENCE iriRef
 23992  
                     {
 23993  38
                     REFERENCE670=(Token)match(input,REFERENCE,FOLLOW_REFERENCE_in_rdfLiteral6689); 
 23994  38
                     REFERENCE670_tree = 
 23995  
                     (Object)adaptor.create(REFERENCE670)
 23996  
                     ;
 23997  38
                     adaptor.addChild(root_0, REFERENCE670_tree);
 23998  
 
 23999  
 
 24000  38
                     pushFollow(FOLLOW_iriRef_in_rdfLiteral6691);
 24001  38
                     iriRef671=iriRef();
 24002  
 
 24003  38
                     state._fsp--;
 24004  
 
 24005  38
                     adaptor.addChild(root_0, iriRef671.getTree());
 24006  
 
 24007  
                     }
 24008  
 
 24009  
 
 24010  
                     }
 24011  
                     break;
 24012  
 
 24013  
             }
 24014  
 
 24015  
 
 24016  
             }
 24017  
 
 24018  378
             retval.stop = input.LT(-1);
 24019  
 
 24020  
 
 24021  378
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 24022  378
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 24023  
 
 24024  
         }
 24025  0
         catch (RecognitionException re) {
 24026  0
             reportError(re);
 24027  0
             recover(input,re);
 24028  0
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 24029  
 
 24030  
         }
 24031  
 
 24032  0
         finally {
 24033  
                 // do for sure before leaving
 24034  378
         }
 24035  378
         return retval;
 24036  
     }
 24037  
     // $ANTLR end "rdfLiteral"
 24038  
 
 24039  
 
 24040  300
     public static class numericLiteral_return extends ParserRuleReturnScope {
 24041  
         Object tree;
 24042  300
         public Object getTree() { return tree; }
 24043  
     };
 24044  
 
 24045  
 
 24046  
     // $ANTLR start "numericLiteral"
 24047  
     // com\\googlecode\\sparkleg\\Sparql.g:635:1: numericLiteral : ( numericLiteralUnsigned | numericLiteralPositive | numericLiteralNegative );
 24048  
     public final SparqlParser.numericLiteral_return numericLiteral() throws RecognitionException {
 24049  300
         SparqlParser.numericLiteral_return retval = new SparqlParser.numericLiteral_return();
 24050  300
         retval.start = input.LT(1);
 24051  
 
 24052  
 
 24053  300
         Object root_0 = null;
 24054  
 
 24055  300
         SparqlParser.numericLiteralUnsigned_return numericLiteralUnsigned672 =null;
 24056  
 
 24057  300
         SparqlParser.numericLiteralPositive_return numericLiteralPositive673 =null;
 24058  
 
 24059  300
         SparqlParser.numericLiteralNegative_return numericLiteralNegative674 =null;
 24060  
 
 24061  
 
 24062  
 
 24063  
         try {
 24064  
             // com\\googlecode\\sparkleg\\Sparql.g:636:5: ( numericLiteralUnsigned | numericLiteralPositive | numericLiteralNegative )
 24065  300
             int alt141=3;
 24066  300
             switch ( input.LA(1) ) {
 24067  
             case DECIMAL:
 24068  
             case DOUBLE:
 24069  
             case INTEGER:
 24070  
                 {
 24071  254
                 alt141=1;
 24072  
                 }
 24073  254
                 break;
 24074  
             case DECIMAL_POSITIVE:
 24075  
             case DOUBLE_POSITIVE:
 24076  
             case INTEGER_POSITIVE:
 24077  
                 {
 24078  30
                 alt141=2;
 24079  
                 }
 24080  30
                 break;
 24081  
             case DECIMAL_NEGATIVE:
 24082  
             case DOUBLE_NEGATIVE:
 24083  
             case INTEGER_NEGATIVE:
 24084  
                 {
 24085  16
                 alt141=3;
 24086  
                 }
 24087  16
                 break;
 24088  
             default:
 24089  0
                 NoViableAltException nvae =
 24090  
                     new NoViableAltException("", 141, 0, input);
 24091  
 
 24092  0
                 throw nvae;
 24093  
 
 24094  
             }
 24095  
 
 24096  300
             switch (alt141) {
 24097  
                 case 1 :
 24098  
                     // com\\googlecode\\sparkleg\\Sparql.g:636:7: numericLiteralUnsigned
 24099  
                     {
 24100  254
                     root_0 = (Object)adaptor.nil();
 24101  
 
 24102  
 
 24103  254
                     pushFollow(FOLLOW_numericLiteralUnsigned_in_numericLiteral6711);
 24104  254
                     numericLiteralUnsigned672=numericLiteralUnsigned();
 24105  
 
 24106  254
                     state._fsp--;
 24107  
 
 24108  254
                     adaptor.addChild(root_0, numericLiteralUnsigned672.getTree());
 24109  
 
 24110  
                     }
 24111  254
                     break;
 24112  
                 case 2 :
 24113  
                     // com\\googlecode\\sparkleg\\Sparql.g:637:7: numericLiteralPositive
 24114  
                     {
 24115  30
                     root_0 = (Object)adaptor.nil();
 24116  
 
 24117  
 
 24118  30
                     pushFollow(FOLLOW_numericLiteralPositive_in_numericLiteral6719);
 24119  30
                     numericLiteralPositive673=numericLiteralPositive();
 24120  
 
 24121  30
                     state._fsp--;
 24122  
 
 24123  30
                     adaptor.addChild(root_0, numericLiteralPositive673.getTree());
 24124  
 
 24125  
                     }
 24126  30
                     break;
 24127  
                 case 3 :
 24128  
                     // com\\googlecode\\sparkleg\\Sparql.g:638:7: numericLiteralNegative
 24129  
                     {
 24130  16
                     root_0 = (Object)adaptor.nil();
 24131  
 
 24132  
 
 24133  16
                     pushFollow(FOLLOW_numericLiteralNegative_in_numericLiteral6727);
 24134  16
                     numericLiteralNegative674=numericLiteralNegative();
 24135  
 
 24136  16
                     state._fsp--;
 24137  
 
 24138  16
                     adaptor.addChild(root_0, numericLiteralNegative674.getTree());
 24139  
 
 24140  
                     }
 24141  
                     break;
 24142  
 
 24143  
             }
 24144  300
             retval.stop = input.LT(-1);
 24145  
 
 24146  
 
 24147  300
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 24148  300
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 24149  
 
 24150  
         }
 24151  0
         catch (RecognitionException re) {
 24152  0
             reportError(re);
 24153  0
             recover(input,re);
 24154  0
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 24155  
 
 24156  
         }
 24157  
 
 24158  0
         finally {
 24159  
                 // do for sure before leaving
 24160  300
         }
 24161  300
         return retval;
 24162  
     }
 24163  
     // $ANTLR end "numericLiteral"
 24164  
 
 24165  
 
 24166  254
     public static class numericLiteralUnsigned_return extends ParserRuleReturnScope {
 24167  
         Object tree;
 24168  254
         public Object getTree() { return tree; }
 24169  
     };
 24170  
 
 24171  
 
 24172  
     // $ANTLR start "numericLiteralUnsigned"
 24173  
     // com\\googlecode\\sparkleg\\Sparql.g:641:1: numericLiteralUnsigned : ( INTEGER | DECIMAL | DOUBLE );
 24174  
     public final SparqlParser.numericLiteralUnsigned_return numericLiteralUnsigned() throws RecognitionException {
 24175  254
         SparqlParser.numericLiteralUnsigned_return retval = new SparqlParser.numericLiteralUnsigned_return();
 24176  254
         retval.start = input.LT(1);
 24177  
 
 24178  
 
 24179  254
         Object root_0 = null;
 24180  
 
 24181  254
         Token set675=null;
 24182  
 
 24183  254
         Object set675_tree=null;
 24184  
 
 24185  
         try {
 24186  
             // com\\googlecode\\sparkleg\\Sparql.g:642:5: ( INTEGER | DECIMAL | DOUBLE )
 24187  
             // com\\googlecode\\sparkleg\\Sparql.g:
 24188  
             {
 24189  254
             root_0 = (Object)adaptor.nil();
 24190  
 
 24191  
 
 24192  254
             set675=(Token)input.LT(1);
 24193  
 
 24194  254
             if ( input.LA(1)==DECIMAL||input.LA(1)==DOUBLE||input.LA(1)==INTEGER ) {
 24195  254
                 input.consume();
 24196  254
                 adaptor.addChild(root_0, 
 24197  
                 (Object)adaptor.create(set675)
 24198  
                 );
 24199  254
                 state.errorRecovery=false;
 24200  
             }
 24201  
             else {
 24202  0
                 MismatchedSetException mse = new MismatchedSetException(null,input);
 24203  0
                 throw mse;
 24204  
             }
 24205  
 
 24206  
 
 24207  
             }
 24208  
 
 24209  254
             retval.stop = input.LT(-1);
 24210  
 
 24211  
 
 24212  254
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 24213  254
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 24214  
 
 24215  
         }
 24216  0
         catch (RecognitionException re) {
 24217  0
             reportError(re);
 24218  0
             recover(input,re);
 24219  0
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 24220  
 
 24221  
         }
 24222  
 
 24223  0
         finally {
 24224  
                 // do for sure before leaving
 24225  254
         }
 24226  254
         return retval;
 24227  
     }
 24228  
     // $ANTLR end "numericLiteralUnsigned"
 24229  
 
 24230  
 
 24231  50
     public static class numericLiteralPositive_return extends ParserRuleReturnScope {
 24232  
         Object tree;
 24233  50
         public Object getTree() { return tree; }
 24234  
     };
 24235  
 
 24236  
 
 24237  
     // $ANTLR start "numericLiteralPositive"
 24238  
     // com\\googlecode\\sparkleg\\Sparql.g:647:1: numericLiteralPositive : ( INTEGER_POSITIVE | DECIMAL_POSITIVE | DOUBLE_POSITIVE );
 24239  
     public final SparqlParser.numericLiteralPositive_return numericLiteralPositive() throws RecognitionException {
 24240  50
         SparqlParser.numericLiteralPositive_return retval = new SparqlParser.numericLiteralPositive_return();
 24241  50
         retval.start = input.LT(1);
 24242  
 
 24243  
 
 24244  50
         Object root_0 = null;
 24245  
 
 24246  50
         Token set676=null;
 24247  
 
 24248  50
         Object set676_tree=null;
 24249  
 
 24250  
         try {
 24251  
             // com\\googlecode\\sparkleg\\Sparql.g:648:5: ( INTEGER_POSITIVE | DECIMAL_POSITIVE | DOUBLE_POSITIVE )
 24252  
             // com\\googlecode\\sparkleg\\Sparql.g:
 24253  
             {
 24254  50
             root_0 = (Object)adaptor.nil();
 24255  
 
 24256  
 
 24257  50
             set676=(Token)input.LT(1);
 24258  
 
 24259  50
             if ( input.LA(1)==DECIMAL_POSITIVE||input.LA(1)==DOUBLE_POSITIVE||input.LA(1)==INTEGER_POSITIVE ) {
 24260  50
                 input.consume();
 24261  50
                 adaptor.addChild(root_0, 
 24262  
                 (Object)adaptor.create(set676)
 24263  
                 );
 24264  50
                 state.errorRecovery=false;
 24265  
             }
 24266  
             else {
 24267  0
                 MismatchedSetException mse = new MismatchedSetException(null,input);
 24268  0
                 throw mse;
 24269  
             }
 24270  
 
 24271  
 
 24272  
             }
 24273  
 
 24274  50
             retval.stop = input.LT(-1);
 24275  
 
 24276  
 
 24277  50
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 24278  50
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 24279  
 
 24280  
         }
 24281  0
         catch (RecognitionException re) {
 24282  0
             reportError(re);
 24283  0
             recover(input,re);
 24284  0
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 24285  
 
 24286  
         }
 24287  
 
 24288  0
         finally {
 24289  
                 // do for sure before leaving
 24290  50
         }
 24291  50
         return retval;
 24292  
     }
 24293  
     // $ANTLR end "numericLiteralPositive"
 24294  
 
 24295  
 
 24296  16
     public static class numericLiteralNegative_return extends ParserRuleReturnScope {
 24297  
         Object tree;
 24298  16
         public Object getTree() { return tree; }
 24299  
     };
 24300  
 
 24301  
 
 24302  
     // $ANTLR start "numericLiteralNegative"
 24303  
     // com\\googlecode\\sparkleg\\Sparql.g:653:1: numericLiteralNegative : ( INTEGER_NEGATIVE | DECIMAL_NEGATIVE | DOUBLE_NEGATIVE );
 24304  
     public final SparqlParser.numericLiteralNegative_return numericLiteralNegative() throws RecognitionException {
 24305  16
         SparqlParser.numericLiteralNegative_return retval = new SparqlParser.numericLiteralNegative_return();
 24306  16
         retval.start = input.LT(1);
 24307  
 
 24308  
 
 24309  16
         Object root_0 = null;
 24310  
 
 24311  16
         Token set677=null;
 24312  
 
 24313  16
         Object set677_tree=null;
 24314  
 
 24315  
         try {
 24316  
             // com\\googlecode\\sparkleg\\Sparql.g:654:5: ( INTEGER_NEGATIVE | DECIMAL_NEGATIVE | DOUBLE_NEGATIVE )
 24317  
             // com\\googlecode\\sparkleg\\Sparql.g:
 24318  
             {
 24319  16
             root_0 = (Object)adaptor.nil();
 24320  
 
 24321  
 
 24322  16
             set677=(Token)input.LT(1);
 24323  
 
 24324  16
             if ( input.LA(1)==DECIMAL_NEGATIVE||input.LA(1)==DOUBLE_NEGATIVE||input.LA(1)==INTEGER_NEGATIVE ) {
 24325  16
                 input.consume();
 24326  16
                 adaptor.addChild(root_0, 
 24327  
                 (Object)adaptor.create(set677)
 24328  
                 );
 24329  16
                 state.errorRecovery=false;
 24330  
             }
 24331  
             else {
 24332  0
                 MismatchedSetException mse = new MismatchedSetException(null,input);
 24333  0
                 throw mse;
 24334  
             }
 24335  
 
 24336  
 
 24337  
             }
 24338  
 
 24339  16
             retval.stop = input.LT(-1);
 24340  
 
 24341  
 
 24342  16
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 24343  16
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 24344  
 
 24345  
         }
 24346  0
         catch (RecognitionException re) {
 24347  0
             reportError(re);
 24348  0
             recover(input,re);
 24349  0
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 24350  
 
 24351  
         }
 24352  
 
 24353  0
         finally {
 24354  
                 // do for sure before leaving
 24355  16
         }
 24356  16
         return retval;
 24357  
     }
 24358  
     // $ANTLR end "numericLiteralNegative"
 24359  
 
 24360  
 
 24361  16
     public static class booleanLiteral_return extends ParserRuleReturnScope {
 24362  
         Object tree;
 24363  16
         public Object getTree() { return tree; }
 24364  
     };
 24365  
 
 24366  
 
 24367  
     // $ANTLR start "booleanLiteral"
 24368  
     // com\\googlecode\\sparkleg\\Sparql.g:659:1: booleanLiteral : ( TRUE | FALSE );
 24369  
     public final SparqlParser.booleanLiteral_return booleanLiteral() throws RecognitionException {
 24370  16
         SparqlParser.booleanLiteral_return retval = new SparqlParser.booleanLiteral_return();
 24371  16
         retval.start = input.LT(1);
 24372  
 
 24373  
 
 24374  16
         Object root_0 = null;
 24375  
 
 24376  16
         Token set678=null;
 24377  
 
 24378  16
         Object set678_tree=null;
 24379  
 
 24380  
         try {
 24381  
             // com\\googlecode\\sparkleg\\Sparql.g:660:5: ( TRUE | FALSE )
 24382  
             // com\\googlecode\\sparkleg\\Sparql.g:
 24383  
             {
 24384  16
             root_0 = (Object)adaptor.nil();
 24385  
 
 24386  
 
 24387  16
             set678=(Token)input.LT(1);
 24388  
 
 24389  16
             if ( input.LA(1)==FALSE||input.LA(1)==TRUE ) {
 24390  16
                 input.consume();
 24391  16
                 adaptor.addChild(root_0, 
 24392  
                 (Object)adaptor.create(set678)
 24393  
                 );
 24394  16
                 state.errorRecovery=false;
 24395  
             }
 24396  
             else {
 24397  0
                 MismatchedSetException mse = new MismatchedSetException(null,input);
 24398  0
                 throw mse;
 24399  
             }
 24400  
 
 24401  
 
 24402  
             }
 24403  
 
 24404  16
             retval.stop = input.LT(-1);
 24405  
 
 24406  
 
 24407  16
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 24408  16
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 24409  
 
 24410  
         }
 24411  0
         catch (RecognitionException re) {
 24412  0
             reportError(re);
 24413  0
             recover(input,re);
 24414  0
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 24415  
 
 24416  
         }
 24417  
 
 24418  0
         finally {
 24419  
                 // do for sure before leaving
 24420  16
         }
 24421  16
         return retval;
 24422  
     }
 24423  
     // $ANTLR end "booleanLiteral"
 24424  
 
 24425  
 
 24426  380
     public static class string_return extends ParserRuleReturnScope {
 24427  
         Object tree;
 24428  380
         public Object getTree() { return tree; }
 24429  
     };
 24430  
 
 24431  
 
 24432  
     // $ANTLR start "string"
 24433  
     // com\\googlecode\\sparkleg\\Sparql.g:664:1: string : ( STRING_LITERAL1 | STRING_LITERAL2 | STRING_LITERAL_LONG1 | STRING_LITERAL_LONG2 );
 24434  
     public final SparqlParser.string_return string() throws RecognitionException {
 24435  380
         SparqlParser.string_return retval = new SparqlParser.string_return();
 24436  380
         retval.start = input.LT(1);
 24437  
 
 24438  
 
 24439  380
         Object root_0 = null;
 24440  
 
 24441  380
         Token set679=null;
 24442  
 
 24443  380
         Object set679_tree=null;
 24444  
 
 24445  
         try {
 24446  
             // com\\googlecode\\sparkleg\\Sparql.g:665:5: ( STRING_LITERAL1 | STRING_LITERAL2 | STRING_LITERAL_LONG1 | STRING_LITERAL_LONG2 )
 24447  
             // com\\googlecode\\sparkleg\\Sparql.g:
 24448  
             {
 24449  380
             root_0 = (Object)adaptor.nil();
 24450  
 
 24451  
 
 24452  380
             set679=(Token)input.LT(1);
 24453  
 
 24454  380
             if ( (input.LA(1) >= STRING_LITERAL1 && input.LA(1) <= STRING_LITERAL_LONG2) ) {
 24455  380
                 input.consume();
 24456  380
                 adaptor.addChild(root_0, 
 24457  
                 (Object)adaptor.create(set679)
 24458  
                 );
 24459  380
                 state.errorRecovery=false;
 24460  
             }
 24461  
             else {
 24462  0
                 MismatchedSetException mse = new MismatchedSetException(null,input);
 24463  0
                 throw mse;
 24464  
             }
 24465  
 
 24466  
 
 24467  
             }
 24468  
 
 24469  380
             retval.stop = input.LT(-1);
 24470  
 
 24471  
 
 24472  380
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 24473  380
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 24474  
 
 24475  
         }
 24476  0
         catch (RecognitionException re) {
 24477  0
             reportError(re);
 24478  0
             recover(input,re);
 24479  0
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 24480  
 
 24481  
         }
 24482  
 
 24483  0
         finally {
 24484  
                 // do for sure before leaving
 24485  380
         }
 24486  380
         return retval;
 24487  
     }
 24488  
     // $ANTLR end "string"
 24489  
 
 24490  
 
 24491  4301
     public static class iriRef_return extends ParserRuleReturnScope {
 24492  
         Object tree;
 24493  4301
         public Object getTree() { return tree; }
 24494  
     };
 24495  
 
 24496  
 
 24497  
     // $ANTLR start "iriRef"
 24498  
     // com\\googlecode\\sparkleg\\Sparql.g:671:1: iriRef : ( IRI_REF | prefixedName );
 24499  
     public final SparqlParser.iriRef_return iriRef() throws RecognitionException {
 24500  4301
         SparqlParser.iriRef_return retval = new SparqlParser.iriRef_return();
 24501  4301
         retval.start = input.LT(1);
 24502  
 
 24503  
 
 24504  4301
         Object root_0 = null;
 24505  
 
 24506  4301
         Token IRI_REF680=null;
 24507  4301
         SparqlParser.prefixedName_return prefixedName681 =null;
 24508  
 
 24509  
 
 24510  4301
         Object IRI_REF680_tree=null;
 24511  
 
 24512  
         try {
 24513  
             // com\\googlecode\\sparkleg\\Sparql.g:672:5: ( IRI_REF | prefixedName )
 24514  4301
             int alt142=2;
 24515  4301
             switch ( input.LA(1) ) {
 24516  
             case IRI_REF:
 24517  
                 {
 24518  466
                 alt142=1;
 24519  
                 }
 24520  466
                 break;
 24521  
             case PNAME_LN:
 24522  
             case PNAME_NS:
 24523  
                 {
 24524  3835
                 alt142=2;
 24525  
                 }
 24526  3835
                 break;
 24527  
             default:
 24528  0
                 NoViableAltException nvae =
 24529  
                     new NoViableAltException("", 142, 0, input);
 24530  
 
 24531  0
                 throw nvae;
 24532  
 
 24533  
             }
 24534  
 
 24535  4301
             switch (alt142) {
 24536  
                 case 1 :
 24537  
                     // com\\googlecode\\sparkleg\\Sparql.g:672:7: IRI_REF
 24538  
                     {
 24539  466
                     root_0 = (Object)adaptor.nil();
 24540  
 
 24541  
 
 24542  466
                     IRI_REF680=(Token)match(input,IRI_REF,FOLLOW_IRI_REF_in_iriRef6910); 
 24543  466
                     IRI_REF680_tree = 
 24544  
                     (Object)adaptor.create(IRI_REF680)
 24545  
                     ;
 24546  466
                     adaptor.addChild(root_0, IRI_REF680_tree);
 24547  
 
 24548  
 
 24549  
                     }
 24550  466
                     break;
 24551  
                 case 2 :
 24552  
                     // com\\googlecode\\sparkleg\\Sparql.g:673:7: prefixedName
 24553  
                     {
 24554  3835
                     root_0 = (Object)adaptor.nil();
 24555  
 
 24556  
 
 24557  3835
                     pushFollow(FOLLOW_prefixedName_in_iriRef6918);
 24558  3835
                     prefixedName681=prefixedName();
 24559  
 
 24560  3835
                     state._fsp--;
 24561  
 
 24562  3835
                     adaptor.addChild(root_0, prefixedName681.getTree());
 24563  
 
 24564  
                     }
 24565  
                     break;
 24566  
 
 24567  
             }
 24568  4301
             retval.stop = input.LT(-1);
 24569  
 
 24570  
 
 24571  4301
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 24572  4301
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 24573  
 
 24574  
         }
 24575  0
         catch (RecognitionException re) {
 24576  0
             reportError(re);
 24577  0
             recover(input,re);
 24578  0
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 24579  
 
 24580  
         }
 24581  
 
 24582  0
         finally {
 24583  
                 // do for sure before leaving
 24584  4301
         }
 24585  4301
         return retval;
 24586  
     }
 24587  
     // $ANTLR end "iriRef"
 24588  
 
 24589  
 
 24590  3835
     public static class prefixedName_return extends ParserRuleReturnScope {
 24591  
         Object tree;
 24592  3835
         public Object getTree() { return tree; }
 24593  
     };
 24594  
 
 24595  
 
 24596  
     // $ANTLR start "prefixedName"
 24597  
     // com\\googlecode\\sparkleg\\Sparql.g:676:1: prefixedName : ( PNAME_LN | PNAME_NS );
 24598  
     public final SparqlParser.prefixedName_return prefixedName() throws RecognitionException {
 24599  3835
         SparqlParser.prefixedName_return retval = new SparqlParser.prefixedName_return();
 24600  3835
         retval.start = input.LT(1);
 24601  
 
 24602  
 
 24603  3835
         Object root_0 = null;
 24604  
 
 24605  3835
         Token set682=null;
 24606  
 
 24607  3835
         Object set682_tree=null;
 24608  
 
 24609  
         try {
 24610  
             // com\\googlecode\\sparkleg\\Sparql.g:677:5: ( PNAME_LN | PNAME_NS )
 24611  
             // com\\googlecode\\sparkleg\\Sparql.g:
 24612  
             {
 24613  3835
             root_0 = (Object)adaptor.nil();
 24614  
 
 24615  
 
 24616  3835
             set682=(Token)input.LT(1);
 24617  
 
 24618  3835
             if ( (input.LA(1) >= PNAME_LN && input.LA(1) <= PNAME_NS) ) {
 24619  3835
                 input.consume();
 24620  3835
                 adaptor.addChild(root_0, 
 24621  
                 (Object)adaptor.create(set682)
 24622  
                 );
 24623  3835
                 state.errorRecovery=false;
 24624  
             }
 24625  
             else {
 24626  0
                 MismatchedSetException mse = new MismatchedSetException(null,input);
 24627  0
                 throw mse;
 24628  
             }
 24629  
 
 24630  
 
 24631  
             }
 24632  
 
 24633  3835
             retval.stop = input.LT(-1);
 24634  
 
 24635  
 
 24636  3835
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 24637  3835
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 24638  
 
 24639  
         }
 24640  0
         catch (RecognitionException re) {
 24641  0
             reportError(re);
 24642  0
             recover(input,re);
 24643  0
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 24644  
 
 24645  
         }
 24646  
 
 24647  0
         finally {
 24648  
                 // do for sure before leaving
 24649  3835
         }
 24650  3835
         return retval;
 24651  
     }
 24652  
     // $ANTLR end "prefixedName"
 24653  
 
 24654  
 
 24655  192
     public static class blankNode_return extends ParserRuleReturnScope {
 24656  
         Object tree;
 24657  192
         public Object getTree() { return tree; }
 24658  
     };
 24659  
 
 24660  
 
 24661  
     // $ANTLR start "blankNode"
 24662  
     // com\\googlecode\\sparkleg\\Sparql.g:681:1: blankNode : ( BLANK_NODE_LABEL | anon );
 24663  
     public final SparqlParser.blankNode_return blankNode() throws RecognitionException {
 24664  192
         SparqlParser.blankNode_return retval = new SparqlParser.blankNode_return();
 24665  192
         retval.start = input.LT(1);
 24666  
 
 24667  
 
 24668  192
         Object root_0 = null;
 24669  
 
 24670  192
         Token BLANK_NODE_LABEL683=null;
 24671  192
         SparqlParser.anon_return anon684 =null;
 24672  
 
 24673  
 
 24674  192
         Object BLANK_NODE_LABEL683_tree=null;
 24675  
 
 24676  
         try {
 24677  
             // com\\googlecode\\sparkleg\\Sparql.g:682:5: ( BLANK_NODE_LABEL | anon )
 24678  192
             int alt143=2;
 24679  192
             switch ( input.LA(1) ) {
 24680  
             case BLANK_NODE_LABEL:
 24681  
                 {
 24682  108
                 alt143=1;
 24683  
                 }
 24684  108
                 break;
 24685  
             case OPEN_SQUARE_BRACKET:
 24686  
                 {
 24687  84
                 alt143=2;
 24688  
                 }
 24689  84
                 break;
 24690  
             default:
 24691  0
                 NoViableAltException nvae =
 24692  
                     new NoViableAltException("", 143, 0, input);
 24693  
 
 24694  0
                 throw nvae;
 24695  
 
 24696  
             }
 24697  
 
 24698  192
             switch (alt143) {
 24699  
                 case 1 :
 24700  
                     // com\\googlecode\\sparkleg\\Sparql.g:682:7: BLANK_NODE_LABEL
 24701  
                     {
 24702  108
                     root_0 = (Object)adaptor.nil();
 24703  
 
 24704  
 
 24705  108
                     BLANK_NODE_LABEL683=(Token)match(input,BLANK_NODE_LABEL,FOLLOW_BLANK_NODE_LABEL_in_blankNode6960); 
 24706  108
                     BLANK_NODE_LABEL683_tree = 
 24707  
                     (Object)adaptor.create(BLANK_NODE_LABEL683)
 24708  
                     ;
 24709  108
                     adaptor.addChild(root_0, BLANK_NODE_LABEL683_tree);
 24710  
 
 24711  
 
 24712  
                     }
 24713  108
                     break;
 24714  
                 case 2 :
 24715  
                     // com\\googlecode\\sparkleg\\Sparql.g:683:7: anon
 24716  
                     {
 24717  84
                     root_0 = (Object)adaptor.nil();
 24718  
 
 24719  
 
 24720  84
                     pushFollow(FOLLOW_anon_in_blankNode6968);
 24721  84
                     anon684=anon();
 24722  
 
 24723  84
                     state._fsp--;
 24724  
 
 24725  84
                     adaptor.addChild(root_0, anon684.getTree());
 24726  
 
 24727  
                     }
 24728  
                     break;
 24729  
 
 24730  
             }
 24731  192
             retval.stop = input.LT(-1);
 24732  
 
 24733  
 
 24734  192
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 24735  192
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 24736  
 
 24737  
         }
 24738  0
         catch (RecognitionException re) {
 24739  0
             reportError(re);
 24740  0
             recover(input,re);
 24741  0
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 24742  
 
 24743  
         }
 24744  
 
 24745  0
         finally {
 24746  
                 // do for sure before leaving
 24747  192
         }
 24748  192
         return retval;
 24749  
     }
 24750  
     // $ANTLR end "blankNode"
 24751  
 
 24752  
 
 24753  84
     public static class anon_return extends ParserRuleReturnScope {
 24754  
         Object tree;
 24755  84
         public Object getTree() { return tree; }
 24756  
     };
 24757  
 
 24758  
 
 24759  
     // $ANTLR start "anon"
 24760  
     // com\\googlecode\\sparkleg\\Sparql.g:686:1: anon : OPEN_SQUARE_BRACKET CLOSE_SQUARE_BRACKET ;
 24761  
     public final SparqlParser.anon_return anon() throws RecognitionException {
 24762  84
         SparqlParser.anon_return retval = new SparqlParser.anon_return();
 24763  84
         retval.start = input.LT(1);
 24764  
 
 24765  
 
 24766  84
         Object root_0 = null;
 24767  
 
 24768  84
         Token OPEN_SQUARE_BRACKET685=null;
 24769  84
         Token CLOSE_SQUARE_BRACKET686=null;
 24770  
 
 24771  84
         Object OPEN_SQUARE_BRACKET685_tree=null;
 24772  84
         Object CLOSE_SQUARE_BRACKET686_tree=null;
 24773  
 
 24774  
         try {
 24775  
             // com\\googlecode\\sparkleg\\Sparql.g:687:5: ( OPEN_SQUARE_BRACKET CLOSE_SQUARE_BRACKET )
 24776  
             // com\\googlecode\\sparkleg\\Sparql.g:687:7: OPEN_SQUARE_BRACKET CLOSE_SQUARE_BRACKET
 24777  
             {
 24778  84
             root_0 = (Object)adaptor.nil();
 24779  
 
 24780  
 
 24781  84
             OPEN_SQUARE_BRACKET685=(Token)match(input,OPEN_SQUARE_BRACKET,FOLLOW_OPEN_SQUARE_BRACKET_in_anon6985); 
 24782  84
             OPEN_SQUARE_BRACKET685_tree = 
 24783  
             (Object)adaptor.create(OPEN_SQUARE_BRACKET685)
 24784  
             ;
 24785  84
             adaptor.addChild(root_0, OPEN_SQUARE_BRACKET685_tree);
 24786  
 
 24787  
 
 24788  84
             CLOSE_SQUARE_BRACKET686=(Token)match(input,CLOSE_SQUARE_BRACKET,FOLLOW_CLOSE_SQUARE_BRACKET_in_anon6987); 
 24789  84
             CLOSE_SQUARE_BRACKET686_tree = 
 24790  
             (Object)adaptor.create(CLOSE_SQUARE_BRACKET686)
 24791  
             ;
 24792  84
             adaptor.addChild(root_0, CLOSE_SQUARE_BRACKET686_tree);
 24793  
 
 24794  
 
 24795  
             }
 24796  
 
 24797  84
             retval.stop = input.LT(-1);
 24798  
 
 24799  
 
 24800  84
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 24801  84
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 24802  
 
 24803  
         }
 24804  0
         catch (RecognitionException re) {
 24805  0
             reportError(re);
 24806  0
             recover(input,re);
 24807  0
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 24808  
 
 24809  
         }
 24810  
 
 24811  0
         finally {
 24812  
                 // do for sure before leaving
 24813  84
         }
 24814  84
         return retval;
 24815  
     }
 24816  
     // $ANTLR end "anon"
 24817  
 
 24818  
     // Delegated rules
 24819  
 
 24820  
 
 24821  1898
     protected DFA4 dfa4 = new DFA4(this);
 24822  
     static final String DFA4_eotS =
 24823  
         "\10\uffff";
 24824  
     static final String DFA4_eofS =
 24825  
         "\10\uffff";
 24826  
     static final String DFA4_minS =
 24827  
         "\1\6\1\133\1\u008a\2\uffff\1\6\1\133\1\6";
 24828  
     static final String DFA4_maxS =
 24829  
         "\1\u00cf\1\133\1\u008a\2\uffff\1\u00cf\1\133\1\u00cf";
 24830  
     static final String DFA4_acceptS =
 24831  
         "\3\uffff\1\1\1\2\3\uffff";
 24832  
     static final String DFA4_specialS =
 24833  
         "\10\uffff}>";
 24834  1
     static final String[] DFA4_transitionS = {
 24835  
             "\1\4\6\uffff\1\3\2\uffff\1\1\12\uffff\1\4\10\uffff\1\3\2\uffff"+
 24836  
             "\1\4\1\uffff\1\4\7\uffff\1\4\1\uffff\1\3\7\uffff\1\4\30\uffff"+
 24837  
             "\1\4\24\uffff\1\4\10\uffff\1\4\36\uffff\1\2\14\uffff\1\3\60"+
 24838  
             "\uffff\1\4",
 24839  
             "\1\5",
 24840  
             "\1\6",
 24841  
             "",
 24842  
             "",
 24843  
             "\1\4\6\uffff\1\3\2\uffff\1\1\12\uffff\1\4\10\uffff\1\3\2\uffff"+
 24844  
             "\1\4\1\uffff\1\4\7\uffff\1\4\1\uffff\1\3\7\uffff\1\4\30\uffff"+
 24845  
             "\1\4\24\uffff\1\4\10\uffff\1\4\36\uffff\1\2\14\uffff\1\3\60"+
 24846  
             "\uffff\1\4",
 24847  
             "\1\7",
 24848  
             "\1\4\6\uffff\1\3\2\uffff\1\1\12\uffff\1\4\10\uffff\1\3\2\uffff"+
 24849  
             "\1\4\1\uffff\1\4\7\uffff\1\4\1\uffff\1\3\7\uffff\1\4\30\uffff"+
 24850  
             "\1\4\24\uffff\1\4\10\uffff\1\4\36\uffff\1\2\14\uffff\1\3\60"+
 24851  
             "\uffff\1\4"
 24852  
     };
 24853  
 
 24854  1
     static final short[] DFA4_eot = DFA.unpackEncodedString(DFA4_eotS);
 24855  1
     static final short[] DFA4_eof = DFA.unpackEncodedString(DFA4_eofS);
 24856  1
     static final char[] DFA4_min = DFA.unpackEncodedStringToUnsignedChars(DFA4_minS);
 24857  1
     static final char[] DFA4_max = DFA.unpackEncodedStringToUnsignedChars(DFA4_maxS);
 24858  1
     static final short[] DFA4_accept = DFA.unpackEncodedString(DFA4_acceptS);
 24859  1
     static final short[] DFA4_special = DFA.unpackEncodedString(DFA4_specialS);
 24860  
     static final short[][] DFA4_transition;
 24861  
 
 24862  
     static {
 24863  1
         int numStates = DFA4_transitionS.length;
 24864  1
         DFA4_transition = new short[numStates][];
 24865  9
         for (int i=0; i<numStates; i++) {
 24866  8
             DFA4_transition[i] = DFA.unpackEncodedString(DFA4_transitionS[i]);
 24867  
         }
 24868  
     }
 24869  
 
 24870  
     class DFA4 extends DFA {
 24871  
 
 24872  1898
         public DFA4(BaseRecognizer recognizer) {
 24873  1898
             this.recognizer = recognizer;
 24874  1898
             this.decisionNumber = 4;
 24875  1898
             this.eot = DFA4_eot;
 24876  1898
             this.eof = DFA4_eof;
 24877  1898
             this.min = DFA4_min;
 24878  1898
             this.max = DFA4_max;
 24879  1898
             this.accept = DFA4_accept;
 24880  1898
             this.special = DFA4_special;
 24881  1898
             this.transition = DFA4_transition;
 24882  1898
         }
 24883  
         public String getDescription() {
 24884  0
             return "76:1: query : ( prologue ( selectQuery | constructQuery | describeQuery | askQuery ) bindingsClause EOF -> ^( QUERY prologue ( selectQuery )* ( constructQuery )* ( describeQuery )* ( askQuery )* ) ( bindingsClause )* | update ( SEMICOLON ( update )? )* EOF -> ^( UPDATE ( update )+ ) );";
 24885  
         }
 24886  
     }
 24887  
  
 24888  
 
 24889  1
     public static final BitSet FOLLOW_prologue_in_query155 = new BitSet(new long[]{0x0008001000002000L,0x0000000000000000L,0x0000000040000000L});
 24890  1
     public static final BitSet FOLLOW_selectQuery_in_query158 = new BitSet(new long[]{0x0000000000040000L});
 24891  1
     public static final BitSet FOLLOW_constructQuery_in_query162 = new BitSet(new long[]{0x0000000000040000L});
 24892  1
     public static final BitSet FOLLOW_describeQuery_in_query166 = new BitSet(new long[]{0x0000000000040000L});
 24893  1
     public static final BitSet FOLLOW_askQuery_in_query170 = new BitSet(new long[]{0x0000000000040000L});
 24894  1
     public static final BitSet FOLLOW_bindingsClause_in_query173 = new BitSet(new long[]{0x0000000000000000L});
 24895  1
     public static final BitSet FOLLOW_EOF_in_query175 = new BitSet(new long[]{0x0000000000000002L});
 24896  1
     public static final BitSet FOLLOW_update_in_query206 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000100000000L});
 24897  1
     public static final BitSet FOLLOW_SEMICOLON_in_query209 = new BitSet(new long[]{0x0802028008010040L,0x0004020000100000L,0x0000000100020000L,0x0000000000008000L});
 24898  1
     public static final BitSet FOLLOW_update_in_query211 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000100000000L});
 24899  1
     public static final BitSet FOLLOW_EOF_in_query216 = new BitSet(new long[]{0x0000000000000002L});
 24900  1
     public static final BitSet FOLLOW_baseDecl_in_prologue249 = new BitSet(new long[]{0x0000000000010002L,0x0000000000000000L,0x0000000000020000L});
 24901  1
     public static final BitSet FOLLOW_prefixDecl_in_prologue253 = new BitSet(new long[]{0x0000000000010002L,0x0000000000000000L,0x0000000000020000L});
 24902  1
     public static final BitSet FOLLOW_BASE_in_baseDecl284 = new BitSet(new long[]{0x0000000000000000L,0x0000000008000000L});
 24903  1
     public static final BitSet FOLLOW_IRI_REF_in_baseDecl286 = new BitSet(new long[]{0x0000000000000002L});
 24904  1
     public static final BitSet FOLLOW_PREFIX_in_prefixDecl312 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000400L});
 24905  1
     public static final BitSet FOLLOW_PNAME_NS_in_prefixDecl314 = new BitSet(new long[]{0x0000000000000000L,0x0000000008000000L});
 24906  1
     public static final BitSet FOLLOW_IRI_REF_in_prefixDecl316 = new BitSet(new long[]{0x0000000000000002L});
 24907  1
     public static final BitSet FOLLOW_selectClause_in_selectQuery343 = new BitSet(new long[]{0x0000000000000000L,0x1000000000000040L,0x0000000000000000L,0x0000000000002000L});
 24908  1
     public static final BitSet FOLLOW_datasetClause_in_selectQuery345 = new BitSet(new long[]{0x0000000000000000L,0x1000000000000040L,0x0000000000000000L,0x0000000000002000L});
 24909  1
     public static final BitSet FOLLOW_whereClause_in_selectQuery348 = new BitSet(new long[]{0x0000000000000000L,0x0400010000010800L,0x0000000000000001L});
 24910  1
     public static final BitSet FOLLOW_solutionModifier_in_selectQuery350 = new BitSet(new long[]{0x0000000000000002L});
 24911  1
     public static final BitSet FOLLOW_selectClause_in_subSelect384 = new BitSet(new long[]{0x0000000000000000L,0x1000000000000000L,0x0000000000000000L,0x0000000000002000L});
 24912  1
     public static final BitSet FOLLOW_whereClause_in_subSelect386 = new BitSet(new long[]{0x0000000000000000L,0x0400010000010800L,0x0000000000000001L});
 24913  1
     public static final BitSet FOLLOW_solutionModifier_in_subSelect388 = new BitSet(new long[]{0x0000000000000002L});
 24914  1
     public static final BitSet FOLLOW_SELECT_in_selectClause424 = new BitSet(new long[]{0x0020000000004000L,0x0000000000000000L,0x0000000000400000L});
 24915  1
     public static final BitSet FOLLOW_DISTINCT_in_selectClause427 = new BitSet(new long[]{0x0000000000004000L});
 24916  1
     public static final BitSet FOLLOW_REDUCED_in_selectClause431 = new BitSet(new long[]{0x0000000000004000L});
 24917  1
     public static final BitSet FOLLOW_ASTERISK_in_selectClause435 = new BitSet(new long[]{0x0000000000000002L});
 24918  1
     public static final BitSet FOLLOW_SELECT_in_selectClause457 = new BitSet(new long[]{0x0020000000000000L,0x0800000000000000L,0x0000000000400000L,0x0000000000000C00L});
 24919  1
     public static final BitSet FOLLOW_DISTINCT_in_selectClause460 = new BitSet(new long[]{0x0000000000000000L,0x0800000000000000L,0x0000000000000000L,0x0000000000000C00L});
 24920  1
     public static final BitSet FOLLOW_REDUCED_in_selectClause464 = new BitSet(new long[]{0x0000000000000000L,0x0800000000000000L,0x0000000000000000L,0x0000000000000C00L});
 24921  1
     public static final BitSet FOLLOW_selectVariables_in_selectClause471 = new BitSet(new long[]{0x0000000000000002L,0x0800000000000000L,0x0000000000000000L,0x0000000000000C00L});
 24922  1
     public static final BitSet FOLLOW_var_in_selectVariables506 = new BitSet(new long[]{0x0000000000000002L});
 24923  1
     public static final BitSet FOLLOW_OPEN_BRACE_in_selectVariables523 = new BitSet(new long[]{0x2700F94884C08020L,0x0932BC2FECE62029L,0x073FFCF83F200700L,0x0000000000020C87L});
 24924  1
     public static final BitSet FOLLOW_expression_in_selectVariables525 = new BitSet(new long[]{0x0000000000000800L});
 24925  1
     public static final BitSet FOLLOW_AS_in_selectVariables527 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000000C00L});
 24926  1
     public static final BitSet FOLLOW_var_in_selectVariables529 = new BitSet(new long[]{0x0000000010000000L});
 24927  1
     public static final BitSet FOLLOW_CLOSE_BRACE_in_selectVariables531 = new BitSet(new long[]{0x0000000000000002L});
 24928  1
     public static final BitSet FOLLOW_CONSTRUCT_in_constructQuery558 = new BitSet(new long[]{0x0000000000000000L,0x1000000000000000L});
 24929  1
     public static final BitSet FOLLOW_constructTemplate_in_constructQuery560 = new BitSet(new long[]{0x0000000000000000L,0x1000000000000040L,0x0000000000000000L,0x0000000000002000L});
 24930  1
     public static final BitSet FOLLOW_datasetClause_in_constructQuery562 = new BitSet(new long[]{0x0000000000000000L,0x1000000000000040L,0x0000000000000000L,0x0000000000002000L});
 24931  1
     public static final BitSet FOLLOW_whereClause_in_constructQuery565 = new BitSet(new long[]{0x0000000000000000L,0x0400010000010800L,0x0000000000000001L});
 24932  1
     public static final BitSet FOLLOW_solutionModifier_in_constructQuery567 = new BitSet(new long[]{0x0000000000000002L});
 24933  1
     public static final BitSet FOLLOW_CONSTRUCT_in_constructQuery592 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000040L,0x0000000000000000L,0x0000000000002000L});
 24934  1
     public static final BitSet FOLLOW_datasetClause_in_constructQuery594 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000040L,0x0000000000000000L,0x0000000000002000L});
 24935  1
     public static final BitSet FOLLOW_WHERE_in_constructQuery597 = new BitSet(new long[]{0x0000000000000000L,0x1000000000000000L});
 24936  1
     public static final BitSet FOLLOW_groupGraphPattern_in_constructQuery599 = new BitSet(new long[]{0x0000000000000000L,0x0400010000010800L,0x0000000000000001L});
 24937  1
     public static final BitSet FOLLOW_solutionModifier_in_constructQuery601 = new BitSet(new long[]{0x0000000000000002L});
 24938  1
     public static final BitSet FOLLOW_DESCRIBE_in_describeQuery637 = new BitSet(new long[]{0x0000000000004000L,0x0000000008000000L,0x0000000000000600L,0x0000000000000C00L});
 24939  1
     public static final BitSet FOLLOW_varOrIRIref_in_describeQuery643 = new BitSet(new long[]{0x0000000000000000L,0x1400010008010840L,0x0000000000000601L,0x0000000000002C00L});
 24940  1
     public static final BitSet FOLLOW_ASTERISK_in_describeQuery649 = new BitSet(new long[]{0x0000000000000000L,0x1400010000010840L,0x0000000000000001L,0x0000000000002000L});
 24941  1
     public static final BitSet FOLLOW_datasetClause_in_describeQuery652 = new BitSet(new long[]{0x0000000000000000L,0x1400010000010840L,0x0000000000000001L,0x0000000000002000L});
 24942  1
     public static final BitSet FOLLOW_whereClause_in_describeQuery655 = new BitSet(new long[]{0x0000000000000000L,0x0400010000010800L,0x0000000000000001L});
 24943  1
     public static final BitSet FOLLOW_solutionModifier_in_describeQuery658 = new BitSet(new long[]{0x0000000000000002L});
 24944  1
     public static final BitSet FOLLOW_ASK_in_askQuery697 = new BitSet(new long[]{0x0000000000000000L,0x1000000000000040L,0x0000000000000000L,0x0000000000002000L});
 24945  1
     public static final BitSet FOLLOW_datasetClause_in_askQuery699 = new BitSet(new long[]{0x0000000000000000L,0x1000000000000040L,0x0000000000000000L,0x0000000000002000L});
 24946  1
     public static final BitSet FOLLOW_whereClause_in_askQuery702 = new BitSet(new long[]{0x0000000000000002L});
 24947  1
     public static final BitSet FOLLOW_FROM_in_datasetClause730 = new BitSet(new long[]{0x0000000000000000L,0x0008000008000000L,0x0000000000000600L});
 24948  1
     public static final BitSet FOLLOW_NAMED_in_datasetClause732 = new BitSet(new long[]{0x0000000000000000L,0x0000000008000000L,0x0000000000000600L});
 24949  1
     public static final BitSet FOLLOW_iriRef_in_datasetClause735 = new BitSet(new long[]{0x0000000000000002L});
 24950  1
     public static final BitSet FOLLOW_WHERE_in_whereClause763 = new BitSet(new long[]{0x0000000000000000L,0x1000000000000000L});
 24951  1
     public static final BitSet FOLLOW_groupGraphPattern_in_whereClause766 = new BitSet(new long[]{0x0000000000000002L});
 24952  1
     public static final BitSet FOLLOW_groupClause_in_solutionModifier791 = new BitSet(new long[]{0x0000000000000002L,0x0400010000010000L,0x0000000000000001L});
 24953  1
     public static final BitSet FOLLOW_havingClause_in_solutionModifier794 = new BitSet(new long[]{0x0000000000000002L,0x0400010000000000L,0x0000000000000001L});
 24954  1
     public static final BitSet FOLLOW_orderClause_in_solutionModifier797 = new BitSet(new long[]{0x0000000000000002L,0x0400010000000000L});
 24955  1
     public static final BitSet FOLLOW_limitOffsetClauses_in_solutionModifier800 = new BitSet(new long[]{0x0000000000000002L});
 24956  1
     public static final BitSet FOLLOW_GROUP_in_groupClause832 = new BitSet(new long[]{0x0000000002000000L});
 24957  1
     public static final BitSet FOLLOW_BY_in_groupClause834 = new BitSet(new long[]{0x2000184884C00020L,0x0922882FEC060021L,0x05387CF82F200600L,0x0000000000020C86L});
 24958  1
     public static final BitSet FOLLOW_groupCondition_in_groupClause836 = new BitSet(new long[]{0x2000184884C00022L,0x0922882FEC060021L,0x05387CF82F200600L,0x0000000000020C86L});
 24959  1
     public static final BitSet FOLLOW_builtInCall_in_groupCondition870 = new BitSet(new long[]{0x0000000000000002L});
 24960  1
     public static final BitSet FOLLOW_functionCall_in_groupCondition886 = new BitSet(new long[]{0x0000000000000002L});
 24961  1
     public static final BitSet FOLLOW_OPEN_BRACE_in_groupCondition902 = new BitSet(new long[]{0x2700F94884C08020L,0x0932BC2FECE62029L,0x073FFCF83F200700L,0x0000000000020C87L});
 24962  1
     public static final BitSet FOLLOW_expression_in_groupCondition904 = new BitSet(new long[]{0x0000000010000800L});
 24963  1
     public static final BitSet FOLLOW_AS_in_groupCondition907 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000000C00L});
 24964  1
     public static final BitSet FOLLOW_var_in_groupCondition909 = new BitSet(new long[]{0x0000000010000000L});
 24965  1
     public static final BitSet FOLLOW_CLOSE_BRACE_in_groupCondition913 = new BitSet(new long[]{0x0000000000000002L});
 24966  1
     public static final BitSet FOLLOW_var_in_groupCondition932 = new BitSet(new long[]{0x0000000000000002L});
 24967  1
     public static final BitSet FOLLOW_HAVING_in_havingClause961 = new BitSet(new long[]{0x2000184884C00020L,0x0922882FEC060021L,0x05387CF82F200600L,0x0000000000020086L});
 24968  1
     public static final BitSet FOLLOW_constraint_in_havingClause963 = new BitSet(new long[]{0x2000184884C00022L,0x0922882FEC060021L,0x05387CF82F200600L,0x0000000000020086L});
 24969  1
     public static final BitSet FOLLOW_ORDER_in_orderClause995 = new BitSet(new long[]{0x0000000002000000L});
 24970  1
     public static final BitSet FOLLOW_BY_in_orderClause997 = new BitSet(new long[]{0x2004184884C01020L,0x0922882FEC060021L,0x05387CF82F200600L,0x0000000000020C86L});
 24971  1
     public static final BitSet FOLLOW_orderCondition_in_orderClause999 = new BitSet(new long[]{0x2004184884C01022L,0x0922882FEC060021L,0x05387CF82F200600L,0x0000000000020C86L});
 24972  1
     public static final BitSet FOLLOW_ASC_in_orderCondition1026 = new BitSet(new long[]{0x0000000000000000L,0x0800000000000000L});
 24973  1
     public static final BitSet FOLLOW_brackettedExpression_in_orderCondition1028 = new BitSet(new long[]{0x0000000000000002L});
 24974  1
     public static final BitSet FOLLOW_DESC_in_orderCondition1046 = new BitSet(new long[]{0x0000000000000000L,0x0800000000000000L});
 24975  1
     public static final BitSet FOLLOW_brackettedExpression_in_orderCondition1048 = new BitSet(new long[]{0x0000000000000002L});
 24976  1
     public static final BitSet FOLLOW_constraint_in_orderCondition1066 = new BitSet(new long[]{0x0000000000000002L});
 24977  1
     public static final BitSet FOLLOW_var_in_orderCondition1082 = new BitSet(new long[]{0x0000000000000002L});
 24978  1
     public static final BitSet FOLLOW_limitClause_in_limitOffsetClauses1112 = new BitSet(new long[]{0x0000000000000002L,0x0400000000000000L});
 24979  1
     public static final BitSet FOLLOW_offsetClause_in_limitOffsetClauses1114 = new BitSet(new long[]{0x0000000000000002L});
 24980  1
     public static final BitSet FOLLOW_offsetClause_in_limitOffsetClauses1130 = new BitSet(new long[]{0x0000000000000002L,0x0000010000000000L});
 24981  1
     public static final BitSet FOLLOW_limitClause_in_limitOffsetClauses1132 = new BitSet(new long[]{0x0000000000000002L});
 24982  1
     public static final BitSet FOLLOW_LIMIT_in_limitClause1157 = new BitSet(new long[]{0x0000000000000000L,0x0000000000200000L});
 24983  1
     public static final BitSet FOLLOW_INTEGER_in_limitClause1159 = new BitSet(new long[]{0x0000000000000002L});
 24984  1
     public static final BitSet FOLLOW_OFFSET_in_offsetClause1184 = new BitSet(new long[]{0x0000000000000000L,0x0000000000200000L});
 24985  1
     public static final BitSet FOLLOW_INTEGER_in_offsetClause1186 = new BitSet(new long[]{0x0000000000000002L});
 24986  1
     public static final BitSet FOLLOW_BINDINGS_in_bindingsClause1212 = new BitSet(new long[]{0x0000000000000000L,0x1000000000000000L,0x0000000000000000L,0x0000000000000C00L});
 24987  1
     public static final BitSet FOLLOW_var_in_bindingsClause1214 = new BitSet(new long[]{0x0000000000000000L,0x1000000000000000L,0x0000000000000000L,0x0000000000000C00L});
 24988  1
     public static final BitSet FOLLOW_OPEN_CURLY_BRACE_in_bindingsClause1217 = new BitSet(new long[]{0x0000000020000000L,0x0800000000000000L});
 24989  1
     public static final BitSet FOLLOW_bindingValueList_in_bindingsClause1219 = new BitSet(new long[]{0x0000000020000000L,0x0800000000000000L});
 24990  1
     public static final BitSet FOLLOW_CLOSE_CURLY_BRACE_in_bindingsClause1222 = new BitSet(new long[]{0x0000000000000002L});
 24991  1
     public static final BitSet FOLLOW_OPEN_BRACE_in_bindingValueList1258 = new BitSet(new long[]{0x0700E00010000000L,0x0000000008E00008L,0x0007800000000600L,0x0000000000000011L});
 24992  1
     public static final BitSet FOLLOW_bindingValue_in_bindingValueList1260 = new BitSet(new long[]{0x0700E00010000000L,0x0000000008E00008L,0x0007800000000600L,0x0000000000000011L});
 24993  1
     public static final BitSet FOLLOW_CLOSE_BRACE_in_bindingValueList1263 = new BitSet(new long[]{0x0000000000000002L});
 24994  1
     public static final BitSet FOLLOW_iriRef_in_bindingValue1294 = new BitSet(new long[]{0x0000000000000002L});
 24995  1
     public static final BitSet FOLLOW_rdfLiteral_in_bindingValue1298 = new BitSet(new long[]{0x0000000000000002L});
 24996  1
     public static final BitSet FOLLOW_numericLiteral_in_bindingValue1302 = new BitSet(new long[]{0x0000000000000002L});
 24997  1
     public static final BitSet FOLLOW_booleanLiteral_in_bindingValue1306 = new BitSet(new long[]{0x0000000000000002L});
 24998  1
     public static final BitSet FOLLOW_UNDEF_in_bindingValue1310 = new BitSet(new long[]{0x0000000000000002L});
 24999  1
     public static final BitSet FOLLOW_prologue_in_update1331 = new BitSet(new long[]{0x0802028008000040L,0x0004020000100000L,0x0000000000000000L,0x0000000000008000L});
 25000  1
     public static final BitSet FOLLOW_load_in_update1334 = new BitSet(new long[]{0x0000000000000002L});
 25001  1
     public static final BitSet FOLLOW_clear_in_update1338 = new BitSet(new long[]{0x0000000000000002L});
 25002  1
     public static final BitSet FOLLOW_drop_in_update1342 = new BitSet(new long[]{0x0000000000000002L});
 25003  1
     public static final BitSet FOLLOW_add_in_update1346 = new BitSet(new long[]{0x0000000000000002L});
 25004  1
     public static final BitSet FOLLOW_move_in_update1350 = new BitSet(new long[]{0x0000000000000002L});
 25005  1
     public static final BitSet FOLLOW_copy_in_update1354 = new BitSet(new long[]{0x0000000000000002L});
 25006  1
     public static final BitSet FOLLOW_create_in_update1358 = new BitSet(new long[]{0x0000000000000002L});
 25007  1
     public static final BitSet FOLLOW_insert_in_update1362 = new BitSet(new long[]{0x0000000000000002L});
 25008  1
     public static final BitSet FOLLOW_delete_in_update1366 = new BitSet(new long[]{0x0000000000000002L});
 25009  1
     public static final BitSet FOLLOW_modify_in_update1370 = new BitSet(new long[]{0x0000000000000002L});
 25010  1
     public static final BitSet FOLLOW_LOAD_in_load1433 = new BitSet(new long[]{0x0000000000000000L,0x0000000008000000L,0x0000020000000600L});
 25011  1
     public static final BitSet FOLLOW_SILENT_in_load1435 = new BitSet(new long[]{0x0000000000000000L,0x0000000008000000L,0x0000000000000600L});
 25012  1
     public static final BitSet FOLLOW_iriRef_in_load1438 = new BitSet(new long[]{0x0000000000000002L,0x0000000001000000L});
 25013  1
     public static final BitSet FOLLOW_INTO_in_load1441 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000100L});
 25014  1
     public static final BitSet FOLLOW_graphRef_in_load1443 = new BitSet(new long[]{0x0000000000000002L});
 25015  1
     public static final BitSet FOLLOW_CLEAR_in_clear1480 = new BitSet(new long[]{0x0001000000000080L,0x0008000000000100L,0x0000020000000000L});
 25016  1
     public static final BitSet FOLLOW_SILENT_in_clear1483 = new BitSet(new long[]{0x0001000000000080L,0x0008000000000100L});
 25017  1
     public static final BitSet FOLLOW_graphRefAll_in_clear1486 = new BitSet(new long[]{0x0000000000000002L});
 25018  1
     public static final BitSet FOLLOW_DROP_in_drop1518 = new BitSet(new long[]{0x0001000000000080L,0x0008000000000100L,0x0000020000000000L});
 25019  1
     public static final BitSet FOLLOW_SILENT_in_drop1520 = new BitSet(new long[]{0x0001000000000080L,0x0008000000000100L});
 25020  1
     public static final BitSet FOLLOW_graphRefAll_in_drop1523 = new BitSet(new long[]{0x0000000000000002L});
 25021  1
     public static final BitSet FOLLOW_CREATE_in_create1552 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000100L,0x0000020000000000L});
 25022  1
     public static final BitSet FOLLOW_SILENT_in_create1554 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000100L});
 25023  1
     public static final BitSet FOLLOW_graphRef_in_create1557 = new BitSet(new long[]{0x0000000000000002L});
 25024  1
     public static final BitSet FOLLOW_ADD_in_add1589 = new BitSet(new long[]{0x0001000000000000L,0x0000000008000100L,0x0000020000000600L});
 25025  1
     public static final BitSet FOLLOW_SILENT_in_add1591 = new BitSet(new long[]{0x0001000000000000L,0x0000000008000100L,0x0000000000000600L});
 25026  1
     public static final BitSet FOLLOW_graphOrDefault_in_add1596 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0800000000000000L});
 25027  1
     public static final BitSet FOLLOW_TO_in_add1598 = new BitSet(new long[]{0x0001000000000000L,0x0000000008000100L,0x0000000000000600L});
 25028  1
     public static final BitSet FOLLOW_graphOrDefault_in_add1602 = new BitSet(new long[]{0x0000000000000002L});
 25029  1
     public static final BitSet FOLLOW_MOVE_in_move1638 = new BitSet(new long[]{0x0001000000000000L,0x0000000008000100L,0x0000020000000600L});
 25030  1
     public static final BitSet FOLLOW_SILENT_in_move1640 = new BitSet(new long[]{0x0001000000000000L,0x0000000008000100L,0x0000000000000600L});
 25031  1
     public static final BitSet FOLLOW_graphOrDefault_in_move1645 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0800000000000000L});
 25032  1
     public static final BitSet FOLLOW_TO_in_move1647 = new BitSet(new long[]{0x0001000000000000L,0x0000000008000100L,0x0000000000000600L});
 25033  1
     public static final BitSet FOLLOW_graphOrDefault_in_move1651 = new BitSet(new long[]{0x0000000000000002L});
 25034  1
     public static final BitSet FOLLOW_COPY_in_copy1687 = new BitSet(new long[]{0x0001000000000000L,0x0000000008000100L,0x0000020000000600L});
 25035  1
     public static final BitSet FOLLOW_SILENT_in_copy1689 = new BitSet(new long[]{0x0001000000000000L,0x0000000008000100L,0x0000000000000600L});
 25036  1
     public static final BitSet FOLLOW_graphOrDefault_in_copy1694 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0800000000000000L});
 25037  1
     public static final BitSet FOLLOW_TO_in_copy1696 = new BitSet(new long[]{0x0001000000000000L,0x0000000008000100L,0x0000000000000600L});
 25038  1
     public static final BitSet FOLLOW_graphOrDefault_in_copy1700 = new BitSet(new long[]{0x0000000000000002L});
 25039  1
     public static final BitSet FOLLOW_INSERT_in_insert1732 = new BitSet(new long[]{0x0000040000000000L});
 25040  1
     public static final BitSet FOLLOW_DATA_in_insert1734 = new BitSet(new long[]{0x0000000000000000L,0x1000000000000000L});
 25041  1
     public static final BitSet FOLLOW_quadPattern_in_insert1736 = new BitSet(new long[]{0x0000000000000002L});
 25042  1
     public static final BitSet FOLLOW_DELETE_in_delete1770 = new BitSet(new long[]{0x0000040000000000L});
 25043  1
     public static final BitSet FOLLOW_deleteData_in_delete1772 = new BitSet(new long[]{0x0000000000000002L});
 25044  1
     public static final BitSet FOLLOW_DELETE_in_delete1788 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000002000L});
 25045  1
     public static final BitSet FOLLOW_deleteWhere_in_delete1790 = new BitSet(new long[]{0x0000000000000002L});
 25046  1
     public static final BitSet FOLLOW_DATA_in_deleteData1815 = new BitSet(new long[]{0x0000000000000000L,0x1000000000000000L});
 25047  1
     public static final BitSet FOLLOW_quadPattern_in_deleteData1817 = new BitSet(new long[]{0x0000000000000002L});
 25048  1
     public static final BitSet FOLLOW_WHERE_in_deleteWhere1844 = new BitSet(new long[]{0x0000000000000000L,0x1000000000000000L});
 25049  1
     public static final BitSet FOLLOW_quadPattern_in_deleteWhere1846 = new BitSet(new long[]{0x0000000000000002L});
 25050  1
     public static final BitSet FOLLOW_WITH_in_modify1878 = new BitSet(new long[]{0x0000000000000000L,0x0000000008000000L,0x0000000000000600L});
 25051  1
     public static final BitSet FOLLOW_iriRef_in_modify1880 = new BitSet(new long[]{0x0002000000000000L,0x0000000000100000L});
 25052  1
     public static final BitSet FOLLOW_deleteClause_in_modify1885 = new BitSet(new long[]{0x0000000000000000L,0x0000000000100000L,0x0000000000000000L,0x0000000000002100L});
 25053  1
     public static final BitSet FOLLOW_insertClause_in_modify1887 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000002100L});
 25054  1
     public static final BitSet FOLLOW_insertClause_in_modify1892 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000002100L});
 25055  1
     public static final BitSet FOLLOW_usingClause_in_modify1895 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000002100L});
 25056  1
     public static final BitSet FOLLOW_WHERE_in_modify1898 = new BitSet(new long[]{0x0000000000000000L,0x1000000000000000L});
 25057  1
     public static final BitSet FOLLOW_groupGraphPattern_in_modify1900 = new BitSet(new long[]{0x0000000000000002L});
 25058  1
     public static final BitSet FOLLOW_DELETE_in_deleteClause1947 = new BitSet(new long[]{0x0000000000000000L,0x1000000000000000L});
 25059  1
     public static final BitSet FOLLOW_quadPattern_in_deleteClause1949 = new BitSet(new long[]{0x0000000000000002L});
 25060  1
     public static final BitSet FOLLOW_INSERT_in_insertClause1980 = new BitSet(new long[]{0x0000000000000000L,0x1000000000000000L});
 25061  1
     public static final BitSet FOLLOW_quadPattern_in_insertClause1982 = new BitSet(new long[]{0x0000000000000002L});
 25062  1
     public static final BitSet FOLLOW_USING_in_usingClause2007 = new BitSet(new long[]{0x0000000000000000L,0x0008000008000000L,0x0000000000000600L});
 25063  1
     public static final BitSet FOLLOW_NAMED_in_usingClause2009 = new BitSet(new long[]{0x0000000000000000L,0x0000000008000000L,0x0000000000000600L});
 25064  1
     public static final BitSet FOLLOW_iriRef_in_usingClause2012 = new BitSet(new long[]{0x0000000000000002L});
 25065  1
     public static final BitSet FOLLOW_DEFAULT_in_graphOrDefault2043 = new BitSet(new long[]{0x0000000000000002L});
 25066  1
     public static final BitSet FOLLOW_GRAPH_in_graphOrDefault2052 = new BitSet(new long[]{0x0000000000000000L,0x0000000008000000L,0x0000000000000600L});
 25067  1
     public static final BitSet FOLLOW_iriRef_in_graphOrDefault2055 = new BitSet(new long[]{0x0000000000000002L});
 25068  1
     public static final BitSet FOLLOW_GRAPH_in_graphRef2082 = new BitSet(new long[]{0x0000000000000000L,0x0000000008000000L,0x0000000000000600L});
 25069  1
     public static final BitSet FOLLOW_iriRef_in_graphRef2084 = new BitSet(new long[]{0x0000000000000002L});
 25070  1
     public static final BitSet FOLLOW_graphRef_in_graphRefAll2101 = new BitSet(new long[]{0x0000000000000002L});
 25071  1
     public static final BitSet FOLLOW_DEFAULT_in_graphRefAll2105 = new BitSet(new long[]{0x0000000000000002L});
 25072  1
     public static final BitSet FOLLOW_NAMED_in_graphRefAll2109 = new BitSet(new long[]{0x0000000000000002L});
 25073  1
     public static final BitSet FOLLOW_ALL_in_graphRefAll2113 = new BitSet(new long[]{0x0000000000000002L});
 25074  1
     public static final BitSet FOLLOW_OPEN_CURLY_BRACE_in_quadPattern2130 = new BitSet(new long[]{0x0700E00020200000L,0x2800000008E00108L,0x0007800000000600L,0x0000000000000C01L});
 25075  1
     public static final BitSet FOLLOW_quads_in_quadPattern2132 = new BitSet(new long[]{0x0000000020000000L});
 25076  1
     public static final BitSet FOLLOW_CLOSE_CURLY_BRACE_in_quadPattern2134 = new BitSet(new long[]{0x0000000000000002L});
 25077  1
     public static final BitSet FOLLOW_triplesTemplate_in_quads2159 = new BitSet(new long[]{0x0000000000000002L,0x0000000000000100L});
 25078  1
     public static final BitSet FOLLOW_quadsDetails_in_quads2162 = new BitSet(new long[]{0x0000000000000002L,0x0000000000000100L});
 25079  1
     public static final BitSet FOLLOW_quadsNotTriples_in_quadsDetails2194 = new BitSet(new long[]{0x0780E00000200002L,0x2800000008E00008L,0x0007800000000600L,0x0000000000000C01L});
 25080  1
     public static final BitSet FOLLOW_DOT_in_quadsDetails2196 = new BitSet(new long[]{0x0700E00000200002L,0x2800000008E00008L,0x0007800000000600L,0x0000000000000C01L});
 25081  1
     public static final BitSet FOLLOW_triplesTemplate_in_quadsDetails2199 = new BitSet(new long[]{0x0000000000000002L});
 25082  1
     public static final BitSet FOLLOW_GRAPH_in_quadsNotTriples2229 = new BitSet(new long[]{0x0000000000000000L,0x0000000008000000L,0x0000000000000600L,0x0000000000000C00L});
 25083  1
     public static final BitSet FOLLOW_varOrIRIref_in_quadsNotTriples2231 = new BitSet(new long[]{0x0000000000000000L,0x1000000000000000L});
 25084  1
     public static final BitSet FOLLOW_OPEN_CURLY_BRACE_in_quadsNotTriples2233 = new BitSet(new long[]{0x0700E00020200000L,0x2800000008E00008L,0x0007800000000600L,0x0000000000000C01L});
 25085  1
     public static final BitSet FOLLOW_triplesTemplate_in_quadsNotTriples2235 = new BitSet(new long[]{0x0000000020000000L});
 25086  1
     public static final BitSet FOLLOW_CLOSE_CURLY_BRACE_in_quadsNotTriples2238 = new BitSet(new long[]{0x0000000000000002L});
 25087  1
     public static final BitSet FOLLOW_triplesSameSubject_in_triplesTemplate2270 = new BitSet(new long[]{0x0080000000000002L});
 25088  1
     public static final BitSet FOLLOW_DOT_in_triplesTemplate2273 = new BitSet(new long[]{0x0700E00000200000L,0x2800000008E00008L,0x0007800000000600L,0x0000000000000C01L});
 25089  1
     public static final BitSet FOLLOW_triplesSameSubject_in_triplesTemplate2275 = new BitSet(new long[]{0x0080000000000002L});
 25090  1
     public static final BitSet FOLLOW_DOT_in_triplesTemplate2279 = new BitSet(new long[]{0x0000000000000002L});
 25091  1
     public static final BitSet FOLLOW_OPEN_CURLY_BRACE_in_groupGraphPattern2311 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000040000000L});
 25092  1
     public static final BitSet FOLLOW_subSelect_in_groupGraphPattern2313 = new BitSet(new long[]{0x0000000020000000L});
 25093  1
     public static final BitSet FOLLOW_CLOSE_CURLY_BRACE_in_groupGraphPattern2315 = new BitSet(new long[]{0x0000000000000002L});
 25094  1
     public static final BitSet FOLLOW_OPEN_CURLY_BRACE_in_groupGraphPattern2331 = new BitSet(new long[]{0x0700E00000220000L,0x7800400008E00118L,0x0007800400000600L,0x0000000000000C01L});
 25095  1
     public static final BitSet FOLLOW_groupGraphPatternSub_in_groupGraphPattern2333 = new BitSet(new long[]{0x0000000020000000L});
 25096  1
     public static final BitSet FOLLOW_CLOSE_CURLY_BRACE_in_groupGraphPattern2335 = new BitSet(new long[]{0x0000000000000002L});
 25097  1
     public static final BitSet FOLLOW_OPEN_CURLY_BRACE_in_groupGraphPattern2351 = new BitSet(new long[]{0x0000000020000000L});
 25098  1
     public static final BitSet FOLLOW_CLOSE_CURLY_BRACE_in_groupGraphPattern2353 = new BitSet(new long[]{0x0000000000000002L});
 25099  1
     public static final BitSet FOLLOW_triplesBlock_in_groupGraphPatternSub2382 = new BitSet(new long[]{0x0000000000020002L,0x5000400000000110L,0x0000000400000000L});
 25100  1
     public static final BitSet FOLLOW_groupGraphPatternSubDetail_in_groupGraphPatternSub2384 = new BitSet(new long[]{0x0000000000020002L,0x5000400000000110L,0x0000000400000000L});
 25101  1
     public static final BitSet FOLLOW_groupGraphPatternSubDetail_in_groupGraphPatternSub2400 = new BitSet(new long[]{0x0000000000020002L,0x5000400000000110L,0x0000000400000000L});
 25102  1
     public static final BitSet FOLLOW_graphPatternNotTriples_in_groupGraphPatternSubDetail2423 = new BitSet(new long[]{0x0780E00000200002L,0x2800000008E00008L,0x0007800000000600L,0x0000000000000C01L});
 25103  1
     public static final BitSet FOLLOW_DOT_in_groupGraphPatternSubDetail2425 = new BitSet(new long[]{0x0700E00000200002L,0x2800000008E00008L,0x0007800000000600L,0x0000000000000C01L});
 25104  1
     public static final BitSet FOLLOW_triplesBlock_in_groupGraphPatternSubDetail2428 = new BitSet(new long[]{0x0000000000000002L});
 25105  1
     public static final BitSet FOLLOW_triplesSameSubjectPath_in_triplesBlock2453 = new BitSet(new long[]{0x0080000000000002L});
 25106  1
     public static final BitSet FOLLOW_DOT_in_triplesBlock2456 = new BitSet(new long[]{0x0700E00000200000L,0x2800000008E00008L,0x0007800000000600L,0x0000000000000C01L});
 25107  1
     public static final BitSet FOLLOW_triplesSameSubjectPath_in_triplesBlock2458 = new BitSet(new long[]{0x0080000000000002L});
 25108  1
     public static final BitSet FOLLOW_DOT_in_triplesBlock2462 = new BitSet(new long[]{0x0000000000000002L});
 25109  1
     public static final BitSet FOLLOW_groupOrUnionGraphPattern_in_graphPatternNotTriples2485 = new BitSet(new long[]{0x0000000000000002L});
 25110  1
     public static final BitSet FOLLOW_optionalGraphPattern_in_graphPatternNotTriples2489 = new BitSet(new long[]{0x0000000000000002L});
 25111  1
     public static final BitSet FOLLOW_minusGraphPattern_in_graphPatternNotTriples2493 = new BitSet(new long[]{0x0000000000000002L});
 25112  1
     public static final BitSet FOLLOW_graphGraphPattern_in_graphPatternNotTriples2497 = new BitSet(new long[]{0x0000000000000002L});
 25113  1
     public static final BitSet FOLLOW_serviceGraphPattern_in_graphPatternNotTriples2501 = new BitSet(new long[]{0x0000000000000002L});
 25114  1
     public static final BitSet FOLLOW_filter_in_graphPatternNotTriples2505 = new BitSet(new long[]{0x0000000000000002L});
 25115  1
     public static final BitSet FOLLOW_bind_in_graphPatternNotTriples2509 = new BitSet(new long[]{0x0000000000000002L});
 25116  1
     public static final BitSet FOLLOW_OPTIONAL_in_optionalGraphPattern2526 = new BitSet(new long[]{0x0000000000000000L,0x1000000000000000L});
 25117  1
     public static final BitSet FOLLOW_groupGraphPattern_in_optionalGraphPattern2528 = new BitSet(new long[]{0x0000000000000002L});
 25118  1
     public static final BitSet FOLLOW_GRAPH_in_graphGraphPattern2553 = new BitSet(new long[]{0x0000000000000000L,0x0000000008000000L,0x0000000000000600L,0x0000000000000C00L});
 25119  1
     public static final BitSet FOLLOW_varOrIRIref_in_graphGraphPattern2555 = new BitSet(new long[]{0x0000000000000000L,0x1000000000000000L});
 25120  1
     public static final BitSet FOLLOW_groupGraphPattern_in_graphGraphPattern2557 = new BitSet(new long[]{0x0000000000000002L});
 25121  1
     public static final BitSet FOLLOW_SERVICE_in_serviceGraphPattern2584 = new BitSet(new long[]{0x0000000000000000L,0x0000000008000000L,0x0000020000000600L,0x0000000000000C00L});
 25122  1
     public static final BitSet FOLLOW_SILENT_in_serviceGraphPattern2586 = new BitSet(new long[]{0x0000000000000000L,0x0000000008000000L,0x0000000000000600L,0x0000000000000C00L});
 25123  1
     public static final BitSet FOLLOW_varOrIRIref_in_serviceGraphPattern2589 = new BitSet(new long[]{0x0000000000000000L,0x1000000000000000L});
 25124  1
     public static final BitSet FOLLOW_groupGraphPattern_in_serviceGraphPattern2591 = new BitSet(new long[]{0x0000000000000002L});
 25125  1
     public static final BitSet FOLLOW_BIND_in_bind2625 = new BitSet(new long[]{0x0000000000000000L,0x0800000000000000L});
 25126  1
     public static final BitSet FOLLOW_OPEN_BRACE_in_bind2627 = new BitSet(new long[]{0x2700F94884C08020L,0x0932BC2FECE62029L,0x073FFCF83F200700L,0x0000000000020C87L});
 25127  1
     public static final BitSet FOLLOW_expression_in_bind2629 = new BitSet(new long[]{0x0000000000000800L});
 25128  1
     public static final BitSet FOLLOW_AS_in_bind2631 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000000C00L});
 25129  1
     public static final BitSet FOLLOW_var_in_bind2633 = new BitSet(new long[]{0x0000000010000000L});
 25130  1
     public static final BitSet FOLLOW_CLOSE_BRACE_in_bind2635 = new BitSet(new long[]{0x0000000000000002L});
 25131  1
     public static final BitSet FOLLOW_MINUS_KEYWORD_in_minusGraphPattern2672 = new BitSet(new long[]{0x0000000000000000L,0x1000000000000000L});
 25132  1
     public static final BitSet FOLLOW_groupGraphPattern_in_minusGraphPattern2674 = new BitSet(new long[]{0x0000000000000002L});
 25133  1
     public static final BitSet FOLLOW_groupGraphPattern_in_groupOrUnionGraphPattern2702 = new BitSet(new long[]{0x0000000000000002L,0x0000000000000000L,0x0000000000000000L,0x0000000000000020L});
 25134  1
     public static final BitSet FOLLOW_UNION_in_groupOrUnionGraphPattern2710 = new BitSet(new long[]{0x0000000000000000L,0x1000000000000000L});
 25135  1
     public static final BitSet FOLLOW_groupGraphPattern_in_groupOrUnionGraphPattern2714 = new BitSet(new long[]{0x0000000000000002L,0x0000000000000000L,0x0000000000000000L,0x0000000000000020L});
 25136  1
     public static final BitSet FOLLOW_FILTER_in_filter2746 = new BitSet(new long[]{0x2000184884C00020L,0x0922882FEC060021L,0x05387CF82F200600L,0x0000000000020086L});
 25137  1
     public static final BitSet FOLLOW_constraint_in_filter2748 = new BitSet(new long[]{0x0000000000000002L});
 25138  1
     public static final BitSet FOLLOW_brackettedExpression_in_constraint2773 = new BitSet(new long[]{0x0000000000000002L});
 25139  1
     public static final BitSet FOLLOW_builtInCall_in_constraint2781 = new BitSet(new long[]{0x0000000000000002L});
 25140  1
     public static final BitSet FOLLOW_functionCall_in_constraint2789 = new BitSet(new long[]{0x0000000000000002L});
 25141  1
     public static final BitSet FOLLOW_iriRef_in_functionCall2806 = new BitSet(new long[]{0x0000000000000000L,0x0800000000000000L});
 25142  1
     public static final BitSet FOLLOW_argList_in_functionCall2808 = new BitSet(new long[]{0x0000000000000002L});
 25143  1
     public static final BitSet FOLLOW_nil_in_argList2839 = new BitSet(new long[]{0x0000000000000002L});
 25144  1
     public static final BitSet FOLLOW_OPEN_BRACE_in_argList2851 = new BitSet(new long[]{0x2720F94884C08020L,0x0932BC2FECE62029L,0x073FFCF83F200700L,0x0000000000020C87L});
 25145  1
     public static final BitSet FOLLOW_DISTINCT_in_argList2853 = new BitSet(new long[]{0x2700F94884C08020L,0x0932BC2FECE62029L,0x073FFCF83F200700L,0x0000000000020C87L});
 25146  1
     public static final BitSet FOLLOW_expression_in_argList2856 = new BitSet(new long[]{0x0000000210000000L});
 25147  1
     public static final BitSet FOLLOW_COMMA_in_argList2859 = new BitSet(new long[]{0x2700F94884C08020L,0x0932BC2FECE62029L,0x073FFCF83F200700L,0x0000000000020C87L});
 25148  1
     public static final BitSet FOLLOW_expression_in_argList2861 = new BitSet(new long[]{0x0000000210000000L});
 25149  1
     public static final BitSet FOLLOW_CLOSE_BRACE_in_argList2865 = new BitSet(new long[]{0x0000000000000002L});
 25150  1
     public static final BitSet FOLLOW_nil_in_expressionList2891 = new BitSet(new long[]{0x0000000000000002L});
 25151  1
     public static final BitSet FOLLOW_OPEN_BRACE_in_expressionList2895 = new BitSet(new long[]{0x2700F94884C08020L,0x0932BC2FECE62029L,0x073FFCF83F200700L,0x0000000000020C87L});
 25152  1
     public static final BitSet FOLLOW_expression_in_expressionList2897 = new BitSet(new long[]{0x0000000210000000L});
 25153  1
     public static final BitSet FOLLOW_COMMA_in_expressionList2900 = new BitSet(new long[]{0x2700F94884C08020L,0x0932BC2FECE62029L,0x073FFCF83F200700L,0x0000000000020C87L});
 25154  1
     public static final BitSet FOLLOW_expression_in_expressionList2902 = new BitSet(new long[]{0x0000000210000000L});
 25155  1
     public static final BitSet FOLLOW_CLOSE_BRACE_in_expressionList2906 = new BitSet(new long[]{0x0000000000000002L});
 25156  1
     public static final BitSet FOLLOW_OPEN_CURLY_BRACE_in_constructTemplate2937 = new BitSet(new long[]{0x0700E00020200000L,0x2800000008E00008L,0x0007800000000600L,0x0000000000000C01L});
 25157  1
     public static final BitSet FOLLOW_constructTriples_in_constructTemplate2939 = new BitSet(new long[]{0x0000000020000000L});
 25158  1
     public static final BitSet FOLLOW_CLOSE_CURLY_BRACE_in_constructTemplate2942 = new BitSet(new long[]{0x0000000000000002L});
 25159  1
     public static final BitSet FOLLOW_triplesSameSubject_in_constructTriples2968 = new BitSet(new long[]{0x0080000000000002L});
 25160  1
     public static final BitSet FOLLOW_DOT_in_constructTriples2971 = new BitSet(new long[]{0x0700E00000200000L,0x2800000008E00008L,0x0007800000000600L,0x0000000000000C01L});
 25161  1
     public static final BitSet FOLLOW_triplesSameSubject_in_constructTriples2973 = new BitSet(new long[]{0x0080000000000002L});
 25162  1
     public static final BitSet FOLLOW_DOT_in_constructTriples2977 = new BitSet(new long[]{0x0000000000000002L});
 25163  1
     public static final BitSet FOLLOW_varOrTerm_in_triplesSameSubject3000 = new BitSet(new long[]{0x0000000000000012L,0x081000000A000000L,0x0000000000000600L,0x0000000000000C00L});
 25164  1
     public static final BitSet FOLLOW_propertyListNotEmpty_in_triplesSameSubject3002 = new BitSet(new long[]{0x0000000000000002L});
 25165  1
     public static final BitSet FOLLOW_triplesNode_in_triplesSameSubject3026 = new BitSet(new long[]{0x0000000000000012L,0x081000000A000000L,0x0000000000000600L,0x0000000000000C00L});
 25166  1
     public static final BitSet FOLLOW_propertyListNotEmpty_in_triplesSameSubject3028 = new BitSet(new long[]{0x0000000000000002L});
 25167  1
     public static final BitSet FOLLOW_propertyListNotEmptyDetails_in_propertyListNotEmpty3058 = new BitSet(new long[]{0x0000000000000002L,0x0000000000000000L,0x0000000100000000L});
 25168  1
     public static final BitSet FOLLOW_SEMICOLON_in_propertyListNotEmpty3061 = new BitSet(new long[]{0x0000000000000012L,0x081000000A000000L,0x0000000100000600L,0x0000000000000C00L});
 25169  1
     public static final BitSet FOLLOW_propertyListNotEmptyDetails_in_propertyListNotEmpty3063 = new BitSet(new long[]{0x0000000000000002L,0x0000000000000000L,0x0000000100000000L});
 25170  1
     public static final BitSet FOLLOW_graphNode_in_objectList3089 = new BitSet(new long[]{0x0000000200000002L});
 25171  1
     public static final BitSet FOLLOW_COMMA_in_objectList3092 = new BitSet(new long[]{0x0700E00000200000L,0x2800000008E00008L,0x0007800000000600L,0x0000000000000C01L});
 25172  1
     public static final BitSet FOLLOW_graphNode_in_objectList3094 = new BitSet(new long[]{0x0000000200000002L});
 25173  1
     public static final BitSet FOLLOW_varOrIRIref_in_verb3122 = new BitSet(new long[]{0x0000000000000002L});
 25174  1
     public static final BitSet FOLLOW_A_in_verb3130 = new BitSet(new long[]{0x0000000000000002L});
 25175  1
     public static final BitSet FOLLOW_varOrTerm_in_triplesSameSubjectPath3147 = new BitSet(new long[]{0x0000000000000010L,0x081000000A000000L,0x0000000000000600L,0x0000000000000C00L});
 25176  1
     public static final BitSet FOLLOW_propertyListNotEmptyPath_in_triplesSameSubjectPath3149 = new BitSet(new long[]{0x0000000000000002L});
 25177  1
     public static final BitSet FOLLOW_triplesNode_in_triplesSameSubjectPath3171 = new BitSet(new long[]{0x0000000000000012L,0x081000000A000000L,0x0000000000000600L,0x0000000000000C00L});
 25178  1
     public static final BitSet FOLLOW_propertyListNotEmpty_in_triplesSameSubjectPath3173 = new BitSet(new long[]{0x0000000000000002L});
 25179  1
     public static final BitSet FOLLOW_propertyListNotEmptyDetails_in_propertyListNotEmptyPath3205 = new BitSet(new long[]{0x0000000000000002L,0x0000000000000000L,0x0000000100000000L});
 25180  1
     public static final BitSet FOLLOW_SEMICOLON_in_propertyListNotEmptyPath3208 = new BitSet(new long[]{0x0000000000000012L,0x081000000A000000L,0x0000000100000600L,0x0000000000000C00L});
 25181  1
     public static final BitSet FOLLOW_propertyListNotEmptyDetails_in_propertyListNotEmptyPath3210 = new BitSet(new long[]{0x0000000000000002L,0x0000000000000000L,0x0000000100000000L});
 25182  1
     public static final BitSet FOLLOW_verbSimpleOrPath_in_propertyListNotEmptyDetails3237 = new BitSet(new long[]{0x0700E00000200000L,0x2800000008E00008L,0x0007800000000600L,0x0000000000000C01L});
 25183  1
     public static final BitSet FOLLOW_objectList_in_propertyListNotEmptyDetails3239 = new BitSet(new long[]{0x0000000000000002L});
 25184  1
     public static final BitSet FOLLOW_verbPath_in_verbSimpleOrPath3269 = new BitSet(new long[]{0x0000000000000002L});
 25185  1
     public static final BitSet FOLLOW_verbSimple_in_verbSimpleOrPath3277 = new BitSet(new long[]{0x0000000000000002L});
 25186  1
     public static final BitSet FOLLOW_path_in_verbPath3296 = new BitSet(new long[]{0x0000000000000002L});
 25187  1
     public static final BitSet FOLLOW_var_in_verbSimple3317 = new BitSet(new long[]{0x0000000000000002L});
 25188  1
     public static final BitSet FOLLOW_pathSequence_in_path3339 = new BitSet(new long[]{0x0000000000000002L,0x0000000000000000L,0x0000000000000080L});
 25189  1
     public static final BitSet FOLLOW_PIPE_in_path3342 = new BitSet(new long[]{0x0000000000000010L,0x081000000A000000L,0x0000000000000600L});
 25190  1
     public static final BitSet FOLLOW_pathSequence_in_path3344 = new BitSet(new long[]{0x0000000000000002L,0x0000000000000000L,0x0000000000000080L});
 25191  1
     public static final BitSet FOLLOW_pathEltOrInverse_in_pathSequence3373 = new BitSet(new long[]{0x0040000000000002L});
 25192  1
     public static final BitSet FOLLOW_DIVIDE_in_pathSequence3376 = new BitSet(new long[]{0x0000000000000010L,0x081000000A000000L,0x0000000000000600L});
 25193  1
     public static final BitSet FOLLOW_pathEltOrInverse_in_pathSequence3378 = new BitSet(new long[]{0x0040000000000002L});
 25194  1
     public static final BitSet FOLLOW_INVERSE_in_pathEltOrInverse3406 = new BitSet(new long[]{0x0000000000000010L,0x0810000008000000L,0x0000000000000600L});
 25195  1
     public static final BitSet FOLLOW_pathElt_in_pathEltOrInverse3409 = new BitSet(new long[]{0x0000000000000002L});
 25196  1
     public static final BitSet FOLLOW_pathPrimary_in_pathElt3437 = new BitSet(new long[]{0x0000000000004002L,0x1000000000000000L,0x0000000000100100L});
 25197  1
     public static final BitSet FOLLOW_pathMod_in_pathElt3439 = new BitSet(new long[]{0x0000000000000002L});
 25198  1
     public static final BitSet FOLLOW_ASTERISK_in_pathMod3458 = new BitSet(new long[]{0x0000000000000002L});
 25199  1
     public static final BitSet FOLLOW_QUESTION_MARK_in_pathMod3462 = new BitSet(new long[]{0x0000000000000002L});
 25200  1
     public static final BitSet FOLLOW_PLUS_in_pathMod3466 = new BitSet(new long[]{0x0000000000000002L});
 25201  1
     public static final BitSet FOLLOW_OPEN_CURLY_BRACE_in_pathMod3470 = new BitSet(new long[]{0x0000000200000000L,0x0000000000200000L});
 25202  1
     public static final BitSet FOLLOW_INTEGER_in_pathMod3473 = new BitSet(new long[]{0x0000000220000000L});
 25203  1
     public static final BitSet FOLLOW_COMMA_in_pathMod3476 = new BitSet(new long[]{0x0000000020000000L,0x0000000000200000L});
 25204  1
     public static final BitSet FOLLOW_CLOSE_CURLY_BRACE_in_pathMod3479 = new BitSet(new long[]{0x0000000000000002L});
 25205  1
     public static final BitSet FOLLOW_INTEGER_in_pathMod3483 = new BitSet(new long[]{0x0000000020000000L});
 25206  1
     public static final BitSet FOLLOW_CLOSE_CURLY_BRACE_in_pathMod3485 = new BitSet(new long[]{0x0000000000000002L});
 25207  1
     public static final BitSet FOLLOW_CLOSE_CURLY_BRACE_in_pathMod3490 = new BitSet(new long[]{0x0000000000000002L});
 25208  1
     public static final BitSet FOLLOW_COMMA_in_pathMod3495 = new BitSet(new long[]{0x0000000000000000L,0x0000000000200000L});
 25209  1
     public static final BitSet FOLLOW_INTEGER_in_pathMod3497 = new BitSet(new long[]{0x0000000020000000L});
 25210  1
     public static final BitSet FOLLOW_CLOSE_CURLY_BRACE_in_pathMod3499 = new BitSet(new long[]{0x0000000000000002L});
 25211  1
     public static final BitSet FOLLOW_iriRef_in_pathPrimary3518 = new BitSet(new long[]{0x0000000000000002L});
 25212  1
     public static final BitSet FOLLOW_A_in_pathPrimary3534 = new BitSet(new long[]{0x0000000000000002L});
 25213  1
     public static final BitSet FOLLOW_NEGATION_in_pathPrimary3550 = new BitSet(new long[]{0x0000000000000010L,0x080000000A000000L,0x0000000000000600L});
 25214  1
     public static final BitSet FOLLOW_pathNegatedPropertySet_in_pathPrimary3552 = new BitSet(new long[]{0x0000000000000002L});
 25215  1
     public static final BitSet FOLLOW_OPEN_BRACE_in_pathPrimary3570 = new BitSet(new long[]{0x0000000000000010L,0x081000000A000000L,0x0000000000000600L});
 25216  1
     public static final BitSet FOLLOW_path_in_pathPrimary3572 = new BitSet(new long[]{0x0000000010000000L});
 25217  1
     public static final BitSet FOLLOW_CLOSE_BRACE_in_pathPrimary3574 = new BitSet(new long[]{0x0000000000000002L});
 25218  1
     public static final BitSet FOLLOW_pathOneInPropertySet_in_pathNegatedPropertySet3599 = new BitSet(new long[]{0x0000000000000002L});
 25219  1
     public static final BitSet FOLLOW_OPEN_BRACE_in_pathNegatedPropertySet3615 = new BitSet(new long[]{0x0000000010000010L,0x000000000A000000L,0x0000000000000600L});
 25220  1
     public static final BitSet FOLLOW_pathOneInPropertySet_in_pathNegatedPropertySet3618 = new BitSet(new long[]{0x0000000010000000L,0x0000000000000000L,0x0000000000000080L});
 25221  1
     public static final BitSet FOLLOW_PIPE_in_pathNegatedPropertySet3621 = new BitSet(new long[]{0x0000000000000010L,0x000000000A000000L,0x0000000000000600L});
 25222  1
     public static final BitSet FOLLOW_pathOneInPropertySet_in_pathNegatedPropertySet3623 = new BitSet(new long[]{0x0000000010000000L,0x0000000000000000L,0x0000000000000080L});
 25223  1
     public static final BitSet FOLLOW_CLOSE_BRACE_in_pathNegatedPropertySet3629 = new BitSet(new long[]{0x0000000000000002L});
 25224  1
     public static final BitSet FOLLOW_INVERSE_in_pathOneInPropertySet3658 = new BitSet(new long[]{0x0000000000000010L,0x0000000008000000L,0x0000000000000600L});
 25225  1
     public static final BitSet FOLLOW_iriRef_in_pathOneInPropertySet3662 = new BitSet(new long[]{0x0000000000000002L});
 25226  1
     public static final BitSet FOLLOW_A_in_pathOneInPropertySet3666 = new BitSet(new long[]{0x0000000000000002L});
 25227  1
     public static final BitSet FOLLOW_OPEN_BRACE_in_triplesNode3685 = new BitSet(new long[]{0x0700E00000200000L,0x2800000008E00008L,0x0007800000000600L,0x0000000000000C01L});
 25228  1
     public static final BitSet FOLLOW_graphNode_in_triplesNode3687 = new BitSet(new long[]{0x0700E00010200000L,0x2800000008E00008L,0x0007800000000600L,0x0000000000000C01L});
 25229  1
     public static final BitSet FOLLOW_CLOSE_BRACE_in_triplesNode3690 = new BitSet(new long[]{0x0000000000000002L});
 25230  1
     public static final BitSet FOLLOW_OPEN_SQUARE_BRACKET_in_triplesNode3707 = new BitSet(new long[]{0x0000000000000010L,0x081000000A000000L,0x0000000000000600L,0x0000000000000C00L});
 25231  1
     public static final BitSet FOLLOW_propertyListNotEmpty_in_triplesNode3709 = new BitSet(new long[]{0x0000000040000000L});
 25232  1
     public static final BitSet FOLLOW_CLOSE_SQUARE_BRACKET_in_triplesNode3711 = new BitSet(new long[]{0x0000000000000002L});
 25233  1
     public static final BitSet FOLLOW_varOrTerm_in_graphNode3736 = new BitSet(new long[]{0x0000000000000002L});
 25234  1
     public static final BitSet FOLLOW_triplesNode_in_graphNode3740 = new BitSet(new long[]{0x0000000000000002L});
 25235  1
     public static final BitSet FOLLOW_var_in_varOrTerm3757 = new BitSet(new long[]{0x0000000000000002L});
 25236  1
     public static final BitSet FOLLOW_graphTerm_in_varOrTerm3765 = new BitSet(new long[]{0x0000000000000002L});
 25237  1
     public static final BitSet FOLLOW_var_in_varOrIRIref3782 = new BitSet(new long[]{0x0000000000000002L});
 25238  1
     public static final BitSet FOLLOW_iriRef_in_varOrIRIref3786 = new BitSet(new long[]{0x0000000000000002L});
 25239  1
     public static final BitSet FOLLOW_iriRef_in_graphTerm3824 = new BitSet(new long[]{0x0000000000000002L});
 25240  1
     public static final BitSet FOLLOW_rdfLiteral_in_graphTerm3832 = new BitSet(new long[]{0x0000000000000002L});
 25241  1
     public static final BitSet FOLLOW_numericLiteral_in_graphTerm3840 = new BitSet(new long[]{0x0000000000000002L});
 25242  1
     public static final BitSet FOLLOW_booleanLiteral_in_graphTerm3848 = new BitSet(new long[]{0x0000000000000002L});
 25243  1
     public static final BitSet FOLLOW_blankNode_in_graphTerm3856 = new BitSet(new long[]{0x0000000000000002L});
 25244  1
     public static final BitSet FOLLOW_nil_in_graphTerm3864 = new BitSet(new long[]{0x0000000000000002L});
 25245  1
     public static final BitSet FOLLOW_OPEN_BRACE_in_nil3885 = new BitSet(new long[]{0x0000000010000000L});
 25246  1
     public static final BitSet FOLLOW_CLOSE_BRACE_in_nil3887 = new BitSet(new long[]{0x0000000000000002L});
 25247  1
     public static final BitSet FOLLOW_conditionalOrExpression_in_expression3904 = new BitSet(new long[]{0x0000000000000002L});
 25248  1
     public static final BitSet FOLLOW_conditionalAndExpression_in_conditionalOrExpression3924 = new BitSet(new long[]{0x0000000000000002L,0x8000000000000000L});
 25249  1
     public static final BitSet FOLLOW_OR_in_conditionalOrExpression3933 = new BitSet(new long[]{0x2700F94884C08020L,0x0932BC2FECE62029L,0x073FFCF83F200700L,0x0000000000020C87L});
 25250  1
     public static final BitSet FOLLOW_conditionalAndExpression_in_conditionalOrExpression3937 = new BitSet(new long[]{0x0000000000000002L,0x8000000000000000L});
 25251  1
     public static final BitSet FOLLOW_valueLogical_in_conditionalAndExpression3971 = new BitSet(new long[]{0x0000000000000102L});
 25252  1
     public static final BitSet FOLLOW_AND_in_conditionalAndExpression3980 = new BitSet(new long[]{0x2700F94884C08020L,0x0932BC2FECE62029L,0x073FFCF83F200700L,0x0000000000020C87L});
 25253  1
     public static final BitSet FOLLOW_valueLogical_in_conditionalAndExpression3984 = new BitSet(new long[]{0x0000000000000102L});
 25254  1
     public static final BitSet FOLLOW_relationalExpression_in_valueLogical4015 = new BitSet(new long[]{0x0000000000000002L});
 25255  1
     public static final BitSet FOLLOW_numericExpression_in_relationalExpression4035 = new BitSet(new long[]{0x8000000000000002L,0x006000C000080600L});
 25256  1
     public static final BitSet FOLLOW_EQUAL_in_relationalExpression4045 = new BitSet(new long[]{0x2700F94884C08020L,0x0932BC2FECE62029L,0x073FFCF83F200700L,0x0000000000020C87L});
 25257  1
     public static final BitSet FOLLOW_numericExpression_in_relationalExpression4049 = new BitSet(new long[]{0x0000000000000002L});
 25258  1
     public static final BitSet FOLLOW_NOT_EQUAL_in_relationalExpression4106 = new BitSet(new long[]{0x2700F94884C08020L,0x0932BC2FECE62029L,0x073FFCF83F200700L,0x0000000000020C87L});
 25259  1
     public static final BitSet FOLLOW_numericExpression_in_relationalExpression4110 = new BitSet(new long[]{0x0000000000000002L});
 25260  1
     public static final BitSet FOLLOW_LESS_in_relationalExpression4165 = new BitSet(new long[]{0x2700F94884C08020L,0x0932BC2FECE62029L,0x073FFCF83F200700L,0x0000000000020C87L});
 25261  1
     public static final BitSet FOLLOW_numericExpression_in_relationalExpression4169 = new BitSet(new long[]{0x0000000000000002L});
 25262  1
     public static final BitSet FOLLOW_GREATER_in_relationalExpression4224 = new BitSet(new long[]{0x2700F94884C08020L,0x0932BC2FECE62029L,0x073FFCF83F200700L,0x0000000000020C87L});
 25263  1
     public static final BitSet FOLLOW_numericExpression_in_relationalExpression4228 = new BitSet(new long[]{0x0000000000000002L});
 25264  1
     public static final BitSet FOLLOW_LESS_EQUAL_in_relationalExpression4282 = new BitSet(new long[]{0x2700F94884C08020L,0x0932BC2FECE62029L,0x073FFCF83F200700L,0x0000000000020C87L});
 25265  1
     public static final BitSet FOLLOW_numericExpression_in_relationalExpression4286 = new BitSet(new long[]{0x0000000000000002L});
 25266  1
     public static final BitSet FOLLOW_GREATER_EQUAL_in_relationalExpression4340 = new BitSet(new long[]{0x2700F94884C08020L,0x0932BC2FECE62029L,0x073FFCF83F200700L,0x0000000000020C87L});
 25267  1
     public static final BitSet FOLLOW_numericExpression_in_relationalExpression4344 = new BitSet(new long[]{0x0000000000000002L});
 25268  1
     public static final BitSet FOLLOW_IN_in_relationalExpression4400 = new BitSet(new long[]{0x0000000000000000L,0x0800000000000000L});
 25269  1
     public static final BitSet FOLLOW_expressionList_in_relationalExpression4404 = new BitSet(new long[]{0x0000000000000002L});
 25270  1
     public static final BitSet FOLLOW_NOT_in_relationalExpression4458 = new BitSet(new long[]{0x0000000000000000L,0x0000000000080000L});
 25271  1
     public static final BitSet FOLLOW_IN_in_relationalExpression4460 = new BitSet(new long[]{0x0000000000000000L,0x0800000000000000L});
 25272  1
     public static final BitSet FOLLOW_expressionList_in_relationalExpression4464 = new BitSet(new long[]{0x0000000000000002L});
 25273  1
     public static final BitSet FOLLOW_additiveExpression_in_numericExpression4498 = new BitSet(new long[]{0x0000000000000002L});
 25274  1
     public static final BitSet FOLLOW_multiplicativeExpression_in_additiveExpression4518 = new BitSet(new long[]{0x0600C00000000002L,0x0000200000C00000L,0x0000000000000100L});
 25275  1
     public static final BitSet FOLLOW_additiveOperator_in_additiveExpression4528 = new BitSet(new long[]{0x2700F94884C08020L,0x0932BC2FECE62029L,0x073FFCF83F200700L,0x0000000000020C87L});
 25276  1
     public static final BitSet FOLLOW_multiplicativeExpression_in_additiveExpression4532 = new BitSet(new long[]{0x0600C00000000002L,0x0000200000C00000L,0x0000000000000100L});
 25277  1
     public static final BitSet FOLLOW_numericLiteralPositive_in_additiveExpression4599 = new BitSet(new long[]{0x0640C00000004002L,0x0000200000C00000L,0x0000000000000100L});
 25278  1
     public static final BitSet FOLLOW_numericLiteralNegative_in_additiveExpression4617 = new BitSet(new long[]{0x0640C00000004002L,0x0000200000C00000L,0x0000000000000100L});
 25279  1
     public static final BitSet FOLLOW_ASTERISK_in_additiveExpression4681 = new BitSet(new long[]{0x2700F94884C08020L,0x0932BC2FECE62029L,0x073FFCF83F200700L,0x0000000000020C87L});
 25280  1
     public static final BitSet FOLLOW_unaryExpression_in_additiveExpression4685 = new BitSet(new long[]{0x0600C00000000002L,0x0000200000C00000L,0x0000000000000100L});
 25281  1
     public static final BitSet FOLLOW_DIVIDE_in_additiveExpression4751 = new BitSet(new long[]{0x2700F94884C08020L,0x0932BC2FECE62029L,0x073FFCF83F200700L,0x0000000000020C87L});
 25282  1
     public static final BitSet FOLLOW_unaryExpression_in_additiveExpression4755 = new BitSet(new long[]{0x0600C00000000002L,0x0000200000C00000L,0x0000000000000100L});
 25283  1
     public static final BitSet FOLLOW_unaryExpression_in_multiplicativeExpression4821 = new BitSet(new long[]{0x0040000000004002L});
 25284  1
     public static final BitSet FOLLOW_multiplicativeOperator_in_multiplicativeExpression4830 = new BitSet(new long[]{0x2700F94884C08020L,0x0932BC2FECE62029L,0x073FFCF83F200700L,0x0000000000020C87L});
 25285  1
     public static final BitSet FOLLOW_unaryExpression_in_multiplicativeExpression4834 = new BitSet(new long[]{0x0040000000004002L});
 25286  1
     public static final BitSet FOLLOW_NEGATION_in_unaryExpression4890 = new BitSet(new long[]{0x2700F94884C08020L,0x09229C2FECE62029L,0x073FFCF83F200600L,0x0000000000020C87L});
 25287  1
     public static final BitSet FOLLOW_primaryExpression_in_unaryExpression4892 = new BitSet(new long[]{0x0000000000000002L});
 25288  1
     public static final BitSet FOLLOW_PLUS_in_unaryExpression4910 = new BitSet(new long[]{0x2700F94884C08020L,0x09229C2FECE62029L,0x073FFCF83F200600L,0x0000000000020C87L});
 25289  1
     public static final BitSet FOLLOW_primaryExpression_in_unaryExpression4912 = new BitSet(new long[]{0x0000000000000002L});
 25290  1
     public static final BitSet FOLLOW_MINUS_in_unaryExpression4930 = new BitSet(new long[]{0x2700F94884C08020L,0x09229C2FECE62029L,0x073FFCF83F200600L,0x0000000000020C87L});
 25291  1
     public static final BitSet FOLLOW_primaryExpression_in_unaryExpression4932 = new BitSet(new long[]{0x0000000000000002L});
 25292  1
     public static final BitSet FOLLOW_primaryExpression_in_unaryExpression4950 = new BitSet(new long[]{0x0000000000000002L});
 25293  1
     public static final BitSet FOLLOW_brackettedExpression_in_primaryExpression4975 = new BitSet(new long[]{0x0000000000000002L});
 25294  1
     public static final BitSet FOLLOW_builtInCall_in_primaryExpression4979 = new BitSet(new long[]{0x0000000000000002L});
 25295  1
     public static final BitSet FOLLOW_iriRefOrFunction_in_primaryExpression4983 = new BitSet(new long[]{0x0000000000000002L});
 25296  1
     public static final BitSet FOLLOW_rdfLiteral_in_primaryExpression4987 = new BitSet(new long[]{0x0000000000000002L});
 25297  1
     public static final BitSet FOLLOW_numericLiteral_in_primaryExpression4991 = new BitSet(new long[]{0x0000000000000002L});
 25298  1
     public static final BitSet FOLLOW_booleanLiteral_in_primaryExpression4995 = new BitSet(new long[]{0x0000000000000002L});
 25299  1
     public static final BitSet FOLLOW_var_in_primaryExpression4999 = new BitSet(new long[]{0x0000000000000002L});
 25300  1
     public static final BitSet FOLLOW_aggregate_in_primaryExpression5003 = new BitSet(new long[]{0x0000000000000002L});
 25301  1
     public static final BitSet FOLLOW_OPEN_BRACE_in_brackettedExpression5020 = new BitSet(new long[]{0x2700F94884C08020L,0x0932BC2FECE62029L,0x073FFCF83F200700L,0x0000000000020C87L});
 25302  1
     public static final BitSet FOLLOW_expression_in_brackettedExpression5022 = new BitSet(new long[]{0x0000000010000000L});
 25303  1
     public static final BitSet FOLLOW_CLOSE_BRACE_in_brackettedExpression5024 = new BitSet(new long[]{0x0000000000000002L});
 25304  1
     public static final BitSet FOLLOW_STR_in_builtInCall5049 = new BitSet(new long[]{0x0000000000000000L,0x0800000000000000L});
 25305  1
     public static final BitSet FOLLOW_OPEN_BRACE_in_builtInCall5051 = new BitSet(new long[]{0x2700F94884C08020L,0x0932BC2FECE62029L,0x073FFCF83F200700L,0x0000000000020C87L});
 25306  1
     public static final BitSet FOLLOW_expression_in_builtInCall5053 = new BitSet(new long[]{0x0000000010000000L});
 25307  1
     public static final BitSet FOLLOW_CLOSE_BRACE_in_builtInCall5055 = new BitSet(new long[]{0x0000000000000002L});
 25308  1
     public static final BitSet FOLLOW_LANG_in_builtInCall5071 = new BitSet(new long[]{0x0000000000000000L,0x0800000000000000L});
 25309  1
     public static final BitSet FOLLOW_OPEN_BRACE_in_builtInCall5073 = new BitSet(new long[]{0x2700F94884C08020L,0x0932BC2FECE62029L,0x073FFCF83F200700L,0x0000000000020C87L});
 25310  1
     public static final BitSet FOLLOW_expression_in_builtInCall5075 = new BitSet(new long[]{0x0000000010000000L});
 25311  1
     public static final BitSet FOLLOW_CLOSE_BRACE_in_builtInCall5077 = new BitSet(new long[]{0x0000000000000002L});
 25312  1
     public static final BitSet FOLLOW_LANGMATCHES_in_builtInCall5093 = new BitSet(new long[]{0x0000000000000000L,0x0800000000000000L});
 25313  1
     public static final BitSet FOLLOW_OPEN_BRACE_in_builtInCall5095 = new BitSet(new long[]{0x2700F94884C08020L,0x0932BC2FECE62029L,0x073FFCF83F200700L,0x0000000000020C87L});
 25314  1
     public static final BitSet FOLLOW_expression_in_builtInCall5097 = new BitSet(new long[]{0x0000000200000000L});
 25315  1
     public static final BitSet FOLLOW_COMMA_in_builtInCall5099 = new BitSet(new long[]{0x2700F94884C08020L,0x0932BC2FECE62029L,0x073FFCF83F200700L,0x0000000000020C87L});
 25316  1
     public static final BitSet FOLLOW_expression_in_builtInCall5101 = new BitSet(new long[]{0x0000000010000000L});
 25317  1
     public static final BitSet FOLLOW_CLOSE_BRACE_in_builtInCall5103 = new BitSet(new long[]{0x0000000000000002L});
 25318  1
     public static final BitSet FOLLOW_DATATYPE_in_builtInCall5120 = new BitSet(new long[]{0x0000000000000000L,0x0800000000000000L});
 25319  1
     public static final BitSet FOLLOW_OPEN_BRACE_in_builtInCall5122 = new BitSet(new long[]{0x2700F94884C08020L,0x0932BC2FECE62029L,0x073FFCF83F200700L,0x0000000000020C87L});
 25320  1
     public static final BitSet FOLLOW_expression_in_builtInCall5124 = new BitSet(new long[]{0x0000000010000000L});
 25321  1
     public static final BitSet FOLLOW_CLOSE_BRACE_in_builtInCall5126 = new BitSet(new long[]{0x0000000000000002L});
 25322  1
     public static final BitSet FOLLOW_BOUND_in_builtInCall5142 = new BitSet(new long[]{0x0000000000000000L,0x0800000000000000L});
 25323  1
     public static final BitSet FOLLOW_OPEN_BRACE_in_builtInCall5144 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000000C00L});
 25324  1
     public static final BitSet FOLLOW_var_in_builtInCall5146 = new BitSet(new long[]{0x0000000010000000L});
 25325  1
     public static final BitSet FOLLOW_CLOSE_BRACE_in_builtInCall5148 = new BitSet(new long[]{0x0000000000000002L});
 25326  1
     public static final BitSet FOLLOW_IRI_in_builtInCall5164 = new BitSet(new long[]{0x0000000000000000L,0x0800000000000000L});
 25327  1
     public static final BitSet FOLLOW_OPEN_BRACE_in_builtInCall5166 = new BitSet(new long[]{0x2700F94884C08020L,0x0932BC2FECE62029L,0x073FFCF83F200700L,0x0000000000020C87L});
 25328  1
     public static final BitSet FOLLOW_expression_in_builtInCall5168 = new BitSet(new long[]{0x0000000010000000L});
 25329  1
     public static final BitSet FOLLOW_CLOSE_BRACE_in_builtInCall5170 = new BitSet(new long[]{0x0000000000000002L});
 25330  1
     public static final BitSet FOLLOW_URI_in_builtInCall5186 = new BitSet(new long[]{0x0000000000000000L,0x0800000000000000L});
 25331  1
     public static final BitSet FOLLOW_OPEN_BRACE_in_builtInCall5188 = new BitSet(new long[]{0x2700F94884C08020L,0x0932BC2FECE62029L,0x073FFCF83F200700L,0x0000000000020C87L});
 25332  1
     public static final BitSet FOLLOW_expression_in_builtInCall5190 = new BitSet(new long[]{0x0000000010000000L});
 25333  1
     public static final BitSet FOLLOW_CLOSE_BRACE_in_builtInCall5192 = new BitSet(new long[]{0x0000000000000002L});
 25334  1
     public static final BitSet FOLLOW_BNODE_in_builtInCall5208 = new BitSet(new long[]{0x0000000000000000L,0x0800000000000000L});
 25335  1
     public static final BitSet FOLLOW_OPEN_BRACE_in_builtInCall5211 = new BitSet(new long[]{0x2700F94884C08020L,0x0932BC2FECE62029L,0x073FFCF83F200700L,0x0000000000020C87L});
 25336  1
     public static final BitSet FOLLOW_expression_in_builtInCall5213 = new BitSet(new long[]{0x0000000010000000L});
 25337  1
     public static final BitSet FOLLOW_CLOSE_BRACE_in_builtInCall5215 = new BitSet(new long[]{0x0000000000000002L});
 25338  1
     public static final BitSet FOLLOW_BNODE_in_builtInCall5232 = new BitSet(new long[]{0x0000000000000000L,0x0800000000000000L});
 25339  1
     public static final BitSet FOLLOW_nil_in_builtInCall5234 = new BitSet(new long[]{0x0000000000000002L});
 25340  1
     public static final BitSet FOLLOW_RAND_in_builtInCall5246 = new BitSet(new long[]{0x0000000000000000L,0x0800000000000000L});
 25341  1
     public static final BitSet FOLLOW_nil_in_builtInCall5248 = new BitSet(new long[]{0x0000000000000002L});
 25342  1
     public static final BitSet FOLLOW_ABS_in_builtInCall5260 = new BitSet(new long[]{0x0000000000000000L,0x0800000000000000L});
 25343  1
     public static final BitSet FOLLOW_OPEN_BRACE_in_builtInCall5262 = new BitSet(new long[]{0x2700F94884C08020L,0x0932BC2FECE62029L,0x073FFCF83F200700L,0x0000000000020C87L});
 25344  1
     public static final BitSet FOLLOW_expression_in_builtInCall5264 = new BitSet(new long[]{0x0000000010000000L});
 25345  1
     public static final BitSet FOLLOW_CLOSE_BRACE_in_builtInCall5266 = new BitSet(new long[]{0x0000000000000002L});
 25346  1
     public static final BitSet FOLLOW_CEIL_in_builtInCall5282 = new BitSet(new long[]{0x0000000000000000L,0x0800000000000000L});
 25347  1
     public static final BitSet FOLLOW_OPEN_BRACE_in_builtInCall5284 = new BitSet(new long[]{0x2700F94884C08020L,0x0932BC2FECE62029L,0x073FFCF83F200700L,0x0000000000020C87L});
 25348  1
     public static final BitSet FOLLOW_expression_in_builtInCall5286 = new BitSet(new long[]{0x0000000010000000L});
 25349  1
     public static final BitSet FOLLOW_CLOSE_BRACE_in_builtInCall5288 = new BitSet(new long[]{0x0000000000000002L});
 25350  1
     public static final BitSet FOLLOW_FLOOR_in_builtInCall5304 = new BitSet(new long[]{0x0000000000000000L,0x0800000000000000L});
 25351  1
     public static final BitSet FOLLOW_OPEN_BRACE_in_builtInCall5306 = new BitSet(new long[]{0x2700F94884C08020L,0x0932BC2FECE62029L,0x073FFCF83F200700L,0x0000000000020C87L});
 25352  1
     public static final BitSet FOLLOW_expression_in_builtInCall5308 = new BitSet(new long[]{0x0000000010000000L});
 25353  1
     public static final BitSet FOLLOW_CLOSE_BRACE_in_builtInCall5310 = new BitSet(new long[]{0x0000000000000002L});
 25354  1
     public static final BitSet FOLLOW_ROUND_in_builtInCall5326 = new BitSet(new long[]{0x0000000000000000L,0x0800000000000000L});
 25355  1
     public static final BitSet FOLLOW_OPEN_BRACE_in_builtInCall5328 = new BitSet(new long[]{0x2700F94884C08020L,0x0932BC2FECE62029L,0x073FFCF83F200700L,0x0000000000020C87L});
 25356  1
     public static final BitSet FOLLOW_expression_in_builtInCall5330 = new BitSet(new long[]{0x0000000010000000L});
 25357  1
     public static final BitSet FOLLOW_CLOSE_BRACE_in_builtInCall5332 = new BitSet(new long[]{0x0000000000000002L});
 25358  1
     public static final BitSet FOLLOW_CONCAT_in_builtInCall5348 = new BitSet(new long[]{0x0000000000000000L,0x0800000000000000L});
 25359  1
     public static final BitSet FOLLOW_expressionList_in_builtInCall5350 = new BitSet(new long[]{0x0000000000000002L});
 25360  1
     public static final BitSet FOLLOW_subStringExpression_in_builtInCall5366 = new BitSet(new long[]{0x0000000000000002L});
 25361  1
     public static final BitSet FOLLOW_STRLEN_in_builtInCall5378 = new BitSet(new long[]{0x0000000000000000L,0x0800000000000000L});
 25362  1
     public static final BitSet FOLLOW_OPEN_BRACE_in_builtInCall5380 = new BitSet(new long[]{0x2700F94884C08020L,0x0932BC2FECE62029L,0x073FFCF83F200700L,0x0000000000020C87L});
 25363  1
     public static final BitSet FOLLOW_expression_in_builtInCall5382 = new BitSet(new long[]{0x0000000010000000L});
 25364  1
     public static final BitSet FOLLOW_CLOSE_BRACE_in_builtInCall5384 = new BitSet(new long[]{0x0000000000000002L});
 25365  1
     public static final BitSet FOLLOW_UCASE_in_builtInCall5400 = new BitSet(new long[]{0x0000000000000000L,0x0800000000000000L});
 25366  1
     public static final BitSet FOLLOW_OPEN_BRACE_in_builtInCall5402 = new BitSet(new long[]{0x2700F94884C08020L,0x0932BC2FECE62029L,0x073FFCF83F200700L,0x0000000000020C87L});
 25367  1
     public static final BitSet FOLLOW_expression_in_builtInCall5404 = new BitSet(new long[]{0x0000000010000000L});
 25368  1
     public static final BitSet FOLLOW_CLOSE_BRACE_in_builtInCall5406 = new BitSet(new long[]{0x0000000000000002L});
 25369  1
     public static final BitSet FOLLOW_LCASE_in_builtInCall5422 = new BitSet(new long[]{0x0000000000000000L,0x0800000000000000L});
 25370  1
     public static final BitSet FOLLOW_OPEN_BRACE_in_builtInCall5424 = new BitSet(new long[]{0x2700F94884C08020L,0x0932BC2FECE62029L,0x073FFCF83F200700L,0x0000000000020C87L});
 25371  1
     public static final BitSet FOLLOW_expression_in_builtInCall5426 = new BitSet(new long[]{0x0000000010000000L});
 25372  1
     public static final BitSet FOLLOW_CLOSE_BRACE_in_builtInCall5428 = new BitSet(new long[]{0x0000000000000002L});
 25373  1
     public static final BitSet FOLLOW_ENCODE_FOR_URI_in_builtInCall5444 = new BitSet(new long[]{0x0000000000000000L,0x0800000000000000L});
 25374  1
     public static final BitSet FOLLOW_OPEN_BRACE_in_builtInCall5446 = new BitSet(new long[]{0x2700F94884C08020L,0x0932BC2FECE62029L,0x073FFCF83F200700L,0x0000000000020C87L});
 25375  1
     public static final BitSet FOLLOW_expression_in_builtInCall5448 = new BitSet(new long[]{0x0000000010000000L});
 25376  1
     public static final BitSet FOLLOW_CLOSE_BRACE_in_builtInCall5450 = new BitSet(new long[]{0x0000000000000002L});
 25377  1
     public static final BitSet FOLLOW_CONTAINS_in_builtInCall5466 = new BitSet(new long[]{0x0000000000000000L,0x0800000000000000L});
 25378  1
     public static final BitSet FOLLOW_OPEN_BRACE_in_builtInCall5468 = new BitSet(new long[]{0x2700F94884C08020L,0x0932BC2FECE62029L,0x073FFCF83F200700L,0x0000000000020C87L});
 25379  1
     public static final BitSet FOLLOW_expression_in_builtInCall5470 = new BitSet(new long[]{0x0000000200000000L});
 25380  1
     public static final BitSet FOLLOW_COMMA_in_builtInCall5472 = new BitSet(new long[]{0x2700F94884C08020L,0x0932BC2FECE62029L,0x073FFCF83F200700L,0x0000000000020C87L});
 25381  1
     public static final BitSet FOLLOW_expression_in_builtInCall5474 = new BitSet(new long[]{0x0000000010000000L});
 25382  1
     public static final BitSet FOLLOW_CLOSE_BRACE_in_builtInCall5476 = new BitSet(new long[]{0x0000000000000002L});
 25383  1
     public static final BitSet FOLLOW_STRSTARTS_in_builtInCall5494 = new BitSet(new long[]{0x0000000000000000L,0x0800000000000000L});
 25384  1
     public static final BitSet FOLLOW_OPEN_BRACE_in_builtInCall5496 = new BitSet(new long[]{0x2700F94884C08020L,0x0932BC2FECE62029L,0x073FFCF83F200700L,0x0000000000020C87L});
 25385  1
     public static final BitSet FOLLOW_expression_in_builtInCall5498 = new BitSet(new long[]{0x0000000200000000L});
 25386  1
     public static final BitSet FOLLOW_COMMA_in_builtInCall5500 = new BitSet(new long[]{0x2700F94884C08020L,0x0932BC2FECE62029L,0x073FFCF83F200700L,0x0000000000020C87L});
 25387  1
     public static final BitSet FOLLOW_expression_in_builtInCall5502 = new BitSet(new long[]{0x0000000010000000L});
 25388  1
     public static final BitSet FOLLOW_CLOSE_BRACE_in_builtInCall5504 = new BitSet(new long[]{0x0000000000000002L});
 25389  1
     public static final BitSet FOLLOW_STRENDS_in_builtInCall5522 = new BitSet(new long[]{0x0000000000000000L,0x0800000000000000L});
 25390  1
     public static final BitSet FOLLOW_OPEN_BRACE_in_builtInCall5524 = new BitSet(new long[]{0x2700F94884C08020L,0x0932BC2FECE62029L,0x073FFCF83F200700L,0x0000000000020C87L});
 25391  1
     public static final BitSet FOLLOW_expression_in_builtInCall5526 = new BitSet(new long[]{0x0000000200000000L});
 25392  1
     public static final BitSet FOLLOW_COMMA_in_builtInCall5528 = new BitSet(new long[]{0x2700F94884C08020L,0x0932BC2FECE62029L,0x073FFCF83F200700L,0x0000000000020C87L});
 25393  1
     public static final BitSet FOLLOW_expression_in_builtInCall5530 = new BitSet(new long[]{0x0000000010000000L});
 25394  1
     public static final BitSet FOLLOW_CLOSE_BRACE_in_builtInCall5532 = new BitSet(new long[]{0x0000000000000002L});
 25395  1
     public static final BitSet FOLLOW_STRBEFORE_in_builtInCall5550 = new BitSet(new long[]{0x0000000000000000L,0x0800000000000000L});
 25396  1
     public static final BitSet FOLLOW_OPEN_BRACE_in_builtInCall5552 = new BitSet(new long[]{0x2700F94884C08020L,0x0932BC2FECE62029L,0x073FFCF83F200700L,0x0000000000020C87L});
 25397  1
     public static final BitSet FOLLOW_expression_in_builtInCall5554 = new BitSet(new long[]{0x0000000200000000L});
 25398  1
     public static final BitSet FOLLOW_COMMA_in_builtInCall5556 = new BitSet(new long[]{0x2700F94884C08020L,0x0932BC2FECE62029L,0x073FFCF83F200700L,0x0000000000020C87L});
 25399  1
     public static final BitSet FOLLOW_expression_in_builtInCall5558 = new BitSet(new long[]{0x0000000010000000L});
 25400  1
     public static final BitSet FOLLOW_CLOSE_BRACE_in_builtInCall5560 = new BitSet(new long[]{0x0000000000000002L});
 25401  1
     public static final BitSet FOLLOW_STRAFTER_in_builtInCall5578 = new BitSet(new long[]{0x0000000000000000L,0x0800000000000000L});
 25402  1
     public static final BitSet FOLLOW_OPEN_BRACE_in_builtInCall5580 = new BitSet(new long[]{0x2700F94884C08020L,0x0932BC2FECE62029L,0x073FFCF83F200700L,0x0000000000020C87L});
 25403  1
     public static final BitSet FOLLOW_expression_in_builtInCall5582 = new BitSet(new long[]{0x0000000200000000L});
 25404  1
     public static final BitSet FOLLOW_COMMA_in_builtInCall5584 = new BitSet(new long[]{0x2700F94884C08020L,0x0932BC2FECE62029L,0x073FFCF83F200700L,0x0000000000020C87L});
 25405  1
     public static final BitSet FOLLOW_expression_in_builtInCall5586 = new BitSet(new long[]{0x0000000010000000L});
 25406  1
     public static final BitSet FOLLOW_CLOSE_BRACE_in_builtInCall5588 = new BitSet(new long[]{0x0000000000000002L});
 25407  1
     public static final BitSet FOLLOW_REPLACE_in_builtInCall5606 = new BitSet(new long[]{0x0000000000000000L,0x0800000000000000L});
 25408  1
     public static final BitSet FOLLOW_OPEN_BRACE_in_builtInCall5608 = new BitSet(new long[]{0x2700F94884C08020L,0x0932BC2FECE62029L,0x073FFCF83F200700L,0x0000000000020C87L});
 25409  1
     public static final BitSet FOLLOW_expression_in_builtInCall5610 = new BitSet(new long[]{0x0000000200000000L});
 25410  1
     public static final BitSet FOLLOW_COMMA_in_builtInCall5612 = new BitSet(new long[]{0x2700F94884C08020L,0x0932BC2FECE62029L,0x073FFCF83F200700L,0x0000000000020C87L});
 25411  1
     public static final BitSet FOLLOW_expression_in_builtInCall5614 = new BitSet(new long[]{0x0000000200000000L});
 25412  1
     public static final BitSet FOLLOW_COMMA_in_builtInCall5616 = new BitSet(new long[]{0x2700F94884C08020L,0x0932BC2FECE62029L,0x073FFCF83F200700L,0x0000000000020C87L});
 25413  1
     public static final BitSet FOLLOW_expression_in_builtInCall5618 = new BitSet(new long[]{0x0000000010000000L});
 25414  1
     public static final BitSet FOLLOW_CLOSE_BRACE_in_builtInCall5620 = new BitSet(new long[]{0x0000000000000002L});
 25415  1
     public static final BitSet FOLLOW_YEAR_in_builtInCall5640 = new BitSet(new long[]{0x0000000000000000L,0x0800000000000000L});
 25416  1
     public static final BitSet FOLLOW_OPEN_BRACE_in_builtInCall5642 = new BitSet(new long[]{0x2700F94884C08020L,0x0932BC2FECE62029L,0x073FFCF83F200700L,0x0000000000020C87L});
 25417  1
     public static final BitSet FOLLOW_expression_in_builtInCall5644 = new BitSet(new long[]{0x0000000010000000L});
 25418  1
     public static final BitSet FOLLOW_CLOSE_BRACE_in_builtInCall5646 = new BitSet(new long[]{0x0000000000000002L});
 25419  1
     public static final BitSet FOLLOW_MONTH_in_builtInCall5662 = new BitSet(new long[]{0x0000000000000000L,0x0800000000000000L});
 25420  1
     public static final BitSet FOLLOW_OPEN_BRACE_in_builtInCall5664 = new BitSet(new long[]{0x2700F94884C08020L,0x0932BC2FECE62029L,0x073FFCF83F200700L,0x0000000000020C87L});
 25421  1
     public static final BitSet FOLLOW_expression_in_builtInCall5666 = new BitSet(new long[]{0x0000000010000000L});
 25422  1
     public static final BitSet FOLLOW_CLOSE_BRACE_in_builtInCall5668 = new BitSet(new long[]{0x0000000000000002L});
 25423  1
     public static final BitSet FOLLOW_DAY_in_builtInCall5684 = new BitSet(new long[]{0x0000000000000000L,0x0800000000000000L});
 25424  1
     public static final BitSet FOLLOW_OPEN_BRACE_in_builtInCall5686 = new BitSet(new long[]{0x2700F94884C08020L,0x0932BC2FECE62029L,0x073FFCF83F200700L,0x0000000000020C87L});
 25425  1
     public static final BitSet FOLLOW_expression_in_builtInCall5688 = new BitSet(new long[]{0x0000000010000000L});
 25426  1
     public static final BitSet FOLLOW_CLOSE_BRACE_in_builtInCall5690 = new BitSet(new long[]{0x0000000000000002L});
 25427  1
     public static final BitSet FOLLOW_HOURS_in_builtInCall5706 = new BitSet(new long[]{0x0000000000000000L,0x0800000000000000L});
 25428  1
     public static final BitSet FOLLOW_OPEN_BRACE_in_builtInCall5708 = new BitSet(new long[]{0x2700F94884C08020L,0x0932BC2FECE62029L,0x073FFCF83F200700L,0x0000000000020C87L});
 25429  1
     public static final BitSet FOLLOW_expression_in_builtInCall5710 = new BitSet(new long[]{0x0000000010000000L});
 25430  1
     public static final BitSet FOLLOW_CLOSE_BRACE_in_builtInCall5712 = new BitSet(new long[]{0x0000000000000002L});
 25431  1
     public static final BitSet FOLLOW_MINUTES_in_builtInCall5728 = new BitSet(new long[]{0x0000000000000000L,0x0800000000000000L});
 25432  1
     public static final BitSet FOLLOW_OPEN_BRACE_in_builtInCall5730 = new BitSet(new long[]{0x2700F94884C08020L,0x0932BC2FECE62029L,0x073FFCF83F200700L,0x0000000000020C87L});
 25433  1
     public static final BitSet FOLLOW_expression_in_builtInCall5732 = new BitSet(new long[]{0x0000000010000000L});
 25434  1
     public static final BitSet FOLLOW_CLOSE_BRACE_in_builtInCall5734 = new BitSet(new long[]{0x0000000000000002L});
 25435  1
     public static final BitSet FOLLOW_SECONDS_in_builtInCall5750 = new BitSet(new long[]{0x0000000000000000L,0x0800000000000000L});
 25436  1
     public static final BitSet FOLLOW_OPEN_BRACE_in_builtInCall5752 = new BitSet(new long[]{0x2700F94884C08020L,0x0932BC2FECE62029L,0x073FFCF83F200700L,0x0000000000020C87L});
 25437  1
     public static final BitSet FOLLOW_expression_in_builtInCall5754 = new BitSet(new long[]{0x0000000010000000L});
 25438  1
     public static final BitSet FOLLOW_CLOSE_BRACE_in_builtInCall5756 = new BitSet(new long[]{0x0000000000000002L});
 25439  1
     public static final BitSet FOLLOW_TIMEZONE_in_builtInCall5772 = new BitSet(new long[]{0x0000000000000000L,0x0800000000000000L});
 25440  1
     public static final BitSet FOLLOW_OPEN_BRACE_in_builtInCall5774 = new BitSet(new long[]{0x2700F94884C08020L,0x0932BC2FECE62029L,0x073FFCF83F200700L,0x0000000000020C87L});
 25441  1
     public static final BitSet FOLLOW_expression_in_builtInCall5776 = new BitSet(new long[]{0x0000000010000000L});
 25442  1
     public static final BitSet FOLLOW_CLOSE_BRACE_in_builtInCall5778 = new BitSet(new long[]{0x0000000000000002L});
 25443  1
     public static final BitSet FOLLOW_TZ_in_builtInCall5794 = new BitSet(new long[]{0x0000000000000000L,0x0800000000000000L});
 25444  1
     public static final BitSet FOLLOW_OPEN_BRACE_in_builtInCall5796 = new BitSet(new long[]{0x2700F94884C08020L,0x0932BC2FECE62029L,0x073FFCF83F200700L,0x0000000000020C87L});
 25445  1
     public static final BitSet FOLLOW_expression_in_builtInCall5798 = new BitSet(new long[]{0x0000000010000000L});
 25446  1
     public static final BitSet FOLLOW_CLOSE_BRACE_in_builtInCall5800 = new BitSet(new long[]{0x0000000000000002L});
 25447  1
     public static final BitSet FOLLOW_NOW_in_builtInCall5816 = new BitSet(new long[]{0x0000000000000000L,0x0800000000000000L});
 25448  1
     public static final BitSet FOLLOW_nil_in_builtInCall5818 = new BitSet(new long[]{0x0000000000000002L});
 25449  1
     public static final BitSet FOLLOW_MD5_in_builtInCall5830 = new BitSet(new long[]{0x0000000000000000L,0x0800000000000000L});
 25450  1
     public static final BitSet FOLLOW_OPEN_BRACE_in_builtInCall5832 = new BitSet(new long[]{0x2700F94884C08020L,0x0932BC2FECE62029L,0x073FFCF83F200700L,0x0000000000020C87L});
 25451  1
     public static final BitSet FOLLOW_expression_in_builtInCall5834 = new BitSet(new long[]{0x0000000010000000L});
 25452  1
     public static final BitSet FOLLOW_CLOSE_BRACE_in_builtInCall5836 = new BitSet(new long[]{0x0000000000000002L});
 25453  1
     public static final BitSet FOLLOW_SHA1_in_builtInCall5852 = new BitSet(new long[]{0x0000000000000000L,0x0800000000000000L});
 25454  1
     public static final BitSet FOLLOW_OPEN_BRACE_in_builtInCall5854 = new BitSet(new long[]{0x2700F94884C08020L,0x0932BC2FECE62029L,0x073FFCF83F200700L,0x0000000000020C87L});
 25455  1
     public static final BitSet FOLLOW_expression_in_builtInCall5856 = new BitSet(new long[]{0x0000000010000000L});
 25456  1
     public static final BitSet FOLLOW_CLOSE_BRACE_in_builtInCall5858 = new BitSet(new long[]{0x0000000000000002L});
 25457  1
     public static final BitSet FOLLOW_SHA224_in_builtInCall5874 = new BitSet(new long[]{0x0000000000000000L,0x0800000000000000L});
 25458  1
     public static final BitSet FOLLOW_OPEN_BRACE_in_builtInCall5876 = new BitSet(new long[]{0x2700F94884C08020L,0x0932BC2FECE62029L,0x073FFCF83F200700L,0x0000000000020C87L});
 25459  1
     public static final BitSet FOLLOW_expression_in_builtInCall5878 = new BitSet(new long[]{0x0000000010000000L});
 25460  1
     public static final BitSet FOLLOW_CLOSE_BRACE_in_builtInCall5880 = new BitSet(new long[]{0x0000000000000002L});
 25461  1
     public static final BitSet FOLLOW_SHA256_in_builtInCall5896 = new BitSet(new long[]{0x0000000000000000L,0x0800000000000000L});
 25462  1
     public static final BitSet FOLLOW_OPEN_BRACE_in_builtInCall5898 = new BitSet(new long[]{0x2700F94884C08020L,0x0932BC2FECE62029L,0x073FFCF83F200700L,0x0000000000020C87L});
 25463  1
     public static final BitSet FOLLOW_expression_in_builtInCall5900 = new BitSet(new long[]{0x0000000010000000L});
 25464  1
     public static final BitSet FOLLOW_CLOSE_BRACE_in_builtInCall5902 = new BitSet(new long[]{0x0000000000000002L});
 25465  1
     public static final BitSet FOLLOW_SHA384_in_builtInCall5918 = new BitSet(new long[]{0x0000000000000000L,0x0800000000000000L});
 25466  1
     public static final BitSet FOLLOW_OPEN_BRACE_in_builtInCall5920 = new BitSet(new long[]{0x2700F94884C08020L,0x0932BC2FECE62029L,0x073FFCF83F200700L,0x0000000000020C87L});
 25467  1
     public static final BitSet FOLLOW_expression_in_builtInCall5922 = new BitSet(new long[]{0x0000000010000000L});
 25468  1
     public static final BitSet FOLLOW_CLOSE_BRACE_in_builtInCall5924 = new BitSet(new long[]{0x0000000000000002L});
 25469  1
     public static final BitSet FOLLOW_SHA512_in_builtInCall5940 = new BitSet(new long[]{0x0000000000000000L,0x0800000000000000L});
 25470  1
     public static final BitSet FOLLOW_OPEN_BRACE_in_builtInCall5942 = new BitSet(new long[]{0x2700F94884C08020L,0x0932BC2FECE62029L,0x073FFCF83F200700L,0x0000000000020C87L});
 25471  1
     public static final BitSet FOLLOW_expression_in_builtInCall5944 = new BitSet(new long[]{0x0000000010000000L});
 25472  1
     public static final BitSet FOLLOW_CLOSE_BRACE_in_builtInCall5946 = new BitSet(new long[]{0x0000000000000002L});
 25473  1
     public static final BitSet FOLLOW_COALESCE_in_builtInCall5962 = new BitSet(new long[]{0x0000000000000000L,0x0800000000000000L});
 25474  1
     public static final BitSet FOLLOW_expressionList_in_builtInCall5964 = new BitSet(new long[]{0x0000000000000002L});
 25475  1
     public static final BitSet FOLLOW_IF_in_builtInCall5980 = new BitSet(new long[]{0x0000000000000000L,0x0800000000000000L});
 25476  1
     public static final BitSet FOLLOW_OPEN_BRACE_in_builtInCall5982 = new BitSet(new long[]{0x2700F94884C08020L,0x0932BC2FECE62029L,0x073FFCF83F200700L,0x0000000000020C87L});
 25477  1
     public static final BitSet FOLLOW_expression_in_builtInCall5986 = new BitSet(new long[]{0x0000000200000000L});
 25478  1
     public static final BitSet FOLLOW_COMMA_in_builtInCall5988 = new BitSet(new long[]{0x2700F94884C08020L,0x0932BC2FECE62029L,0x073FFCF83F200700L,0x0000000000020C87L});
 25479  1
     public static final BitSet FOLLOW_expression_in_builtInCall5992 = new BitSet(new long[]{0x0000000200000000L});
 25480  1
     public static final BitSet FOLLOW_COMMA_in_builtInCall5994 = new BitSet(new long[]{0x2700F94884C08020L,0x0932BC2FECE62029L,0x073FFCF83F200700L,0x0000000000020C87L});
 25481  1
     public static final BitSet FOLLOW_expression_in_builtInCall5998 = new BitSet(new long[]{0x0000000010000000L});
 25482  1
     public static final BitSet FOLLOW_CLOSE_BRACE_in_builtInCall6000 = new BitSet(new long[]{0x0000000000000002L});
 25483  1
     public static final BitSet FOLLOW_STRLANG_in_builtInCall6023 = new BitSet(new long[]{0x0000000000000000L,0x0800000000000000L});
 25484  1
     public static final BitSet FOLLOW_OPEN_BRACE_in_builtInCall6025 = new BitSet(new long[]{0x2700F94884C08020L,0x0932BC2FECE62029L,0x073FFCF83F200700L,0x0000000000020C87L});
 25485  1
     public static final BitSet FOLLOW_expression_in_builtInCall6027 = new BitSet(new long[]{0x0000000200000000L});
 25486  1
     public static final BitSet FOLLOW_COMMA_in_builtInCall6029 = new BitSet(new long[]{0x2700F94884C08020L,0x0932BC2FECE62029L,0x073FFCF83F200700L,0x0000000000020C87L});
 25487  1
     public static final BitSet FOLLOW_expression_in_builtInCall6031 = new BitSet(new long[]{0x0000000010000000L});
 25488  1
     public static final BitSet FOLLOW_CLOSE_BRACE_in_builtInCall6033 = new BitSet(new long[]{0x0000000000000002L});
 25489  1
     public static final BitSet FOLLOW_STRDT_in_builtInCall6051 = new BitSet(new long[]{0x0000000000000000L,0x0800000000000000L});
 25490  1
     public static final BitSet FOLLOW_OPEN_BRACE_in_builtInCall6053 = new BitSet(new long[]{0x2700F94884C08020L,0x0932BC2FECE62029L,0x073FFCF83F200700L,0x0000000000020C87L});
 25491  1
     public static final BitSet FOLLOW_expression_in_builtInCall6055 = new BitSet(new long[]{0x0000000200000000L});
 25492  1
     public static final BitSet FOLLOW_COMMA_in_builtInCall6057 = new BitSet(new long[]{0x2700F94884C08020L,0x0932BC2FECE62029L,0x073FFCF83F200700L,0x0000000000020C87L});
 25493  1
     public static final BitSet FOLLOW_expression_in_builtInCall6059 = new BitSet(new long[]{0x0000000010000000L});
 25494  1
     public static final BitSet FOLLOW_CLOSE_BRACE_in_builtInCall6061 = new BitSet(new long[]{0x0000000000000002L});
 25495  1
     public static final BitSet FOLLOW_SAMETERM_in_builtInCall6079 = new BitSet(new long[]{0x0000000000000000L,0x0800000000000000L});
 25496  1
     public static final BitSet FOLLOW_OPEN_BRACE_in_builtInCall6081 = new BitSet(new long[]{0x2700F94884C08020L,0x0932BC2FECE62029L,0x073FFCF83F200700L,0x0000000000020C87L});
 25497  1
     public static final BitSet FOLLOW_expression_in_builtInCall6083 = new BitSet(new long[]{0x0000000200000000L});
 25498  1
     public static final BitSet FOLLOW_COMMA_in_builtInCall6085 = new BitSet(new long[]{0x2700F94884C08020L,0x0932BC2FECE62029L,0x073FFCF83F200700L,0x0000000000020C87L});
 25499  1
     public static final BitSet FOLLOW_expression_in_builtInCall6087 = new BitSet(new long[]{0x0000000010000000L});
 25500  1
     public static final BitSet FOLLOW_CLOSE_BRACE_in_builtInCall6089 = new BitSet(new long[]{0x0000000000000002L});
 25501  1
     public static final BitSet FOLLOW_ISIRI_in_builtInCall6107 = new BitSet(new long[]{0x0000000000000000L,0x0800000000000000L});
 25502  1
     public static final BitSet FOLLOW_OPEN_BRACE_in_builtInCall6109 = new BitSet(new long[]{0x2700F94884C08020L,0x0932BC2FECE62029L,0x073FFCF83F200700L,0x0000000000020C87L});
 25503  1
     public static final BitSet FOLLOW_expression_in_builtInCall6111 = new BitSet(new long[]{0x0000000010000000L});
 25504  1
     public static final BitSet FOLLOW_CLOSE_BRACE_in_builtInCall6113 = new BitSet(new long[]{0x0000000000000002L});
 25505  1
     public static final BitSet FOLLOW_ISURI_in_builtInCall6129 = new BitSet(new long[]{0x0000000000000000L,0x0800000000000000L});
 25506  1
     public static final BitSet FOLLOW_OPEN_BRACE_in_builtInCall6131 = new BitSet(new long[]{0x2700F94884C08020L,0x0932BC2FECE62029L,0x073FFCF83F200700L,0x0000000000020C87L});
 25507  1
     public static final BitSet FOLLOW_expression_in_builtInCall6133 = new BitSet(new long[]{0x0000000010000000L});
 25508  1
     public static final BitSet FOLLOW_CLOSE_BRACE_in_builtInCall6135 = new BitSet(new long[]{0x0000000000000002L});
 25509  1
     public static final BitSet FOLLOW_ISBLANK_in_builtInCall6151 = new BitSet(new long[]{0x0000000000000000L,0x0800000000000000L});
 25510  1
     public static final BitSet FOLLOW_OPEN_BRACE_in_builtInCall6153 = new BitSet(new long[]{0x2700F94884C08020L,0x0932BC2FECE62029L,0x073FFCF83F200700L,0x0000000000020C87L});
 25511  1
     public static final BitSet FOLLOW_expression_in_builtInCall6155 = new BitSet(new long[]{0x0000000010000000L});
 25512  1
     public static final BitSet FOLLOW_CLOSE_BRACE_in_builtInCall6157 = new BitSet(new long[]{0x0000000000000002L});
 25513  1
     public static final BitSet FOLLOW_ISLITERAL_in_builtInCall6174 = new BitSet(new long[]{0x0000000000000000L,0x0800000000000000L});
 25514  1
     public static final BitSet FOLLOW_OPEN_BRACE_in_builtInCall6176 = new BitSet(new long[]{0x2700F94884C08020L,0x0932BC2FECE62029L,0x073FFCF83F200700L,0x0000000000020C87L});
 25515  1
     public static final BitSet FOLLOW_expression_in_builtInCall6178 = new BitSet(new long[]{0x0000000010000000L});
 25516  1
     public static final BitSet FOLLOW_CLOSE_BRACE_in_builtInCall6180 = new BitSet(new long[]{0x0000000000000002L});
 25517  1
     public static final BitSet FOLLOW_ISNUMERIC_in_builtInCall6196 = new BitSet(new long[]{0x0000000000000000L,0x0800000000000000L});
 25518  1
     public static final BitSet FOLLOW_OPEN_BRACE_in_builtInCall6198 = new BitSet(new long[]{0x2700F94884C08020L,0x0932BC2FECE62029L,0x073FFCF83F200700L,0x0000000000020C87L});
 25519  1
     public static final BitSet FOLLOW_expression_in_builtInCall6200 = new BitSet(new long[]{0x0000000010000000L});
 25520  1
     public static final BitSet FOLLOW_CLOSE_BRACE_in_builtInCall6202 = new BitSet(new long[]{0x0000000000000002L});
 25521  1
     public static final BitSet FOLLOW_regexExpression_in_builtInCall6218 = new BitSet(new long[]{0x0000000000000002L});
 25522  1
     public static final BitSet FOLLOW_existsFunction_in_builtInCall6230 = new BitSet(new long[]{0x0000000000000002L});
 25523  1
     public static final BitSet FOLLOW_notExistsFunction_in_builtInCall6242 = new BitSet(new long[]{0x0000000000000002L});
 25524  1
     public static final BitSet FOLLOW_REGEX_in_regexExpression6263 = new BitSet(new long[]{0x0000000000000000L,0x0800000000000000L});
 25525  1
     public static final BitSet FOLLOW_OPEN_BRACE_in_regexExpression6265 = new BitSet(new long[]{0x2700F94884C08020L,0x0932BC2FECE62029L,0x073FFCF83F200700L,0x0000000000020C87L});
 25526  1
     public static final BitSet FOLLOW_expression_in_regexExpression6267 = new BitSet(new long[]{0x0000000200000000L});
 25527  1
     public static final BitSet FOLLOW_COMMA_in_regexExpression6269 = new BitSet(new long[]{0x2700F94884C08020L,0x0932BC2FECE62029L,0x073FFCF83F200700L,0x0000000000020C87L});
 25528  1
     public static final BitSet FOLLOW_expression_in_regexExpression6271 = new BitSet(new long[]{0x0000000210000000L});
 25529  1
     public static final BitSet FOLLOW_COMMA_in_regexExpression6274 = new BitSet(new long[]{0x2700F94884C08020L,0x0932BC2FECE62029L,0x073FFCF83F200700L,0x0000000000020C87L});
 25530  1
     public static final BitSet FOLLOW_expression_in_regexExpression6276 = new BitSet(new long[]{0x0000000010000000L});
 25531  1
     public static final BitSet FOLLOW_CLOSE_BRACE_in_regexExpression6280 = new BitSet(new long[]{0x0000000000000002L});
 25532  1
     public static final BitSet FOLLOW_SUBSTR_in_subStringExpression6310 = new BitSet(new long[]{0x0000000000000000L,0x0800000000000000L});
 25533  1
     public static final BitSet FOLLOW_OPEN_BRACE_in_subStringExpression6312 = new BitSet(new long[]{0x2700F94884C08020L,0x0932BC2FECE62029L,0x073FFCF83F200700L,0x0000000000020C87L});
 25534  1
     public static final BitSet FOLLOW_expression_in_subStringExpression6314 = new BitSet(new long[]{0x0000000200000000L});
 25535  1
     public static final BitSet FOLLOW_COMMA_in_subStringExpression6316 = new BitSet(new long[]{0x2700F94884C08020L,0x0932BC2FECE62029L,0x073FFCF83F200700L,0x0000000000020C87L});
 25536  1
     public static final BitSet FOLLOW_expression_in_subStringExpression6318 = new BitSet(new long[]{0x0000000210000000L});
 25537  1
     public static final BitSet FOLLOW_COMMA_in_subStringExpression6321 = new BitSet(new long[]{0x2700F94884C08020L,0x0932BC2FECE62029L,0x073FFCF83F200700L,0x0000000000020C87L});
 25538  1
     public static final BitSet FOLLOW_expression_in_subStringExpression6323 = new BitSet(new long[]{0x0000000010000000L});
 25539  1
     public static final BitSet FOLLOW_CLOSE_BRACE_in_subStringExpression6327 = new BitSet(new long[]{0x0000000000000002L});
 25540  1
     public static final BitSet FOLLOW_EXISTS_in_existsFunction6357 = new BitSet(new long[]{0x0000000000000000L,0x1000000000000000L});
 25541  1
     public static final BitSet FOLLOW_groupGraphPattern_in_existsFunction6359 = new BitSet(new long[]{0x0000000000000002L});
 25542  1
     public static final BitSet FOLLOW_NOT_in_notExistsFunction6384 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000001L});
 25543  1
     public static final BitSet FOLLOW_EXISTS_in_notExistsFunction6386 = new BitSet(new long[]{0x0000000000000000L,0x1000000000000000L});
 25544  1
     public static final BitSet FOLLOW_groupGraphPattern_in_notExistsFunction6388 = new BitSet(new long[]{0x0000000000000002L});
 25545  1
     public static final BitSet FOLLOW_COUNT_in_aggregate6413 = new BitSet(new long[]{0x0000000000000000L,0x0800000000000000L});
 25546  1
     public static final BitSet FOLLOW_OPEN_BRACE_in_aggregate6415 = new BitSet(new long[]{0x2720F94884C0C020L,0x0932BC2FECE62029L,0x073FFCF83F200700L,0x0000000000020C87L});
 25547  1
     public static final BitSet FOLLOW_DISTINCT_in_aggregate6417 = new BitSet(new long[]{0x2700F94884C0C020L,0x0932BC2FECE62029L,0x073FFCF83F200700L,0x0000000000020C87L});
 25548  1
     public static final BitSet FOLLOW_ASTERISK_in_aggregate6421 = new BitSet(new long[]{0x0000000010000000L});
 25549  1
     public static final BitSet FOLLOW_expression_in_aggregate6425 = new BitSet(new long[]{0x0000000010000000L});
 25550  1
     public static final BitSet FOLLOW_CLOSE_BRACE_in_aggregate6428 = new BitSet(new long[]{0x0000000000000002L});
 25551  1
     public static final BitSet FOLLOW_SUM_in_aggregate6451 = new BitSet(new long[]{0x0000000000000000L,0x0800000000000000L});
 25552  1
     public static final BitSet FOLLOW_OPEN_BRACE_in_aggregate6453 = new BitSet(new long[]{0x2720F94884C08020L,0x0932BC2FECE62029L,0x073FFCF83F200700L,0x0000000000020C87L});
 25553  1
     public static final BitSet FOLLOW_DISTINCT_in_aggregate6455 = new BitSet(new long[]{0x2700F94884C08020L,0x0932BC2FECE62029L,0x073FFCF83F200700L,0x0000000000020C87L});
 25554  1
     public static final BitSet FOLLOW_expression_in_aggregate6458 = new BitSet(new long[]{0x0000000010000000L});
 25555  1
     public static final BitSet FOLLOW_CLOSE_BRACE_in_aggregate6460 = new BitSet(new long[]{0x0000000000000002L});
 25556  1
     public static final BitSet FOLLOW_MIN_in_aggregate6479 = new BitSet(new long[]{0x0000000000000000L,0x0800000000000000L});
 25557  1
     public static final BitSet FOLLOW_OPEN_BRACE_in_aggregate6481 = new BitSet(new long[]{0x2720F94884C08020L,0x0932BC2FECE62029L,0x073FFCF83F200700L,0x0000000000020C87L});
 25558  1
     public static final BitSet FOLLOW_DISTINCT_in_aggregate6483 = new BitSet(new long[]{0x2700F94884C08020L,0x0932BC2FECE62029L,0x073FFCF83F200700L,0x0000000000020C87L});
 25559  1
     public static final BitSet FOLLOW_expression_in_aggregate6486 = new BitSet(new long[]{0x0000000010000000L});
 25560  1
     public static final BitSet FOLLOW_CLOSE_BRACE_in_aggregate6488 = new BitSet(new long[]{0x0000000000000002L});
 25561  1
     public static final BitSet FOLLOW_MAX_in_aggregate6507 = new BitSet(new long[]{0x0000000000000000L,0x0800000000000000L});
 25562  1
     public static final BitSet FOLLOW_OPEN_BRACE_in_aggregate6509 = new BitSet(new long[]{0x2720F94884C08020L,0x0932BC2FECE62029L,0x073FFCF83F200700L,0x0000000000020C87L});
 25563  1
     public static final BitSet FOLLOW_DISTINCT_in_aggregate6511 = new BitSet(new long[]{0x2700F94884C08020L,0x0932BC2FECE62029L,0x073FFCF83F200700L,0x0000000000020C87L});
 25564  1
     public static final BitSet FOLLOW_expression_in_aggregate6514 = new BitSet(new long[]{0x0000000010000000L});
 25565  1
     public static final BitSet FOLLOW_CLOSE_BRACE_in_aggregate6516 = new BitSet(new long[]{0x0000000000000002L});
 25566  1
     public static final BitSet FOLLOW_AVG_in_aggregate6535 = new BitSet(new long[]{0x0000000000000000L,0x0800000000000000L});
 25567  1
     public static final BitSet FOLLOW_OPEN_BRACE_in_aggregate6537 = new BitSet(new long[]{0x2720F94884C08020L,0x0932BC2FECE62029L,0x073FFCF83F200700L,0x0000000000020C87L});
 25568  1
     public static final BitSet FOLLOW_DISTINCT_in_aggregate6539 = new BitSet(new long[]{0x2700F94884C08020L,0x0932BC2FECE62029L,0x073FFCF83F200700L,0x0000000000020C87L});
 25569  1
     public static final BitSet FOLLOW_expression_in_aggregate6542 = new BitSet(new long[]{0x0000000010000000L});
 25570  1
     public static final BitSet FOLLOW_CLOSE_BRACE_in_aggregate6544 = new BitSet(new long[]{0x0000000000000002L});
 25571  1
     public static final BitSet FOLLOW_SAMPLE_in_aggregate6563 = new BitSet(new long[]{0x0000000000000000L,0x0800000000000000L});
 25572  1
     public static final BitSet FOLLOW_OPEN_BRACE_in_aggregate6565 = new BitSet(new long[]{0x2720F94884C08020L,0x0932BC2FECE62029L,0x073FFCF83F200700L,0x0000000000020C87L});
 25573  1
     public static final BitSet FOLLOW_DISTINCT_in_aggregate6567 = new BitSet(new long[]{0x2700F94884C08020L,0x0932BC2FECE62029L,0x073FFCF83F200700L,0x0000000000020C87L});
 25574  1
     public static final BitSet FOLLOW_expression_in_aggregate6570 = new BitSet(new long[]{0x0000000010000000L});
 25575  1
     public static final BitSet FOLLOW_CLOSE_BRACE_in_aggregate6572 = new BitSet(new long[]{0x0000000000000002L});
 25576  1
     public static final BitSet FOLLOW_GROUP_CONCAT_in_aggregate6591 = new BitSet(new long[]{0x0000000000000000L,0x0800000000000000L});
 25577  1
     public static final BitSet FOLLOW_OPEN_BRACE_in_aggregate6593 = new BitSet(new long[]{0x2720F94884C08020L,0x0932BC2FECE62029L,0x073FFCF83F200700L,0x0000000000020C87L});
 25578  1
     public static final BitSet FOLLOW_DISTINCT_in_aggregate6595 = new BitSet(new long[]{0x2700F94884C08020L,0x0932BC2FECE62029L,0x073FFCF83F200700L,0x0000000000020C87L});
 25579  1
     public static final BitSet FOLLOW_expression_in_aggregate6598 = new BitSet(new long[]{0x0000000010000000L,0x0000000000000000L,0x0000000100000000L});
 25580  1
     public static final BitSet FOLLOW_SEMICOLON_in_aggregate6601 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000200000000L});
 25581  1
     public static final BitSet FOLLOW_SEPARATOR_in_aggregate6603 = new BitSet(new long[]{0x8000000000000000L});
 25582  1
     public static final BitSet FOLLOW_EQUAL_in_aggregate6605 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0007800000000000L});
 25583  1
     public static final BitSet FOLLOW_string_in_aggregate6607 = new BitSet(new long[]{0x0000000010000000L});
 25584  1
     public static final BitSet FOLLOW_CLOSE_BRACE_in_aggregate6611 = new BitSet(new long[]{0x0000000000000002L});
 25585  1
     public static final BitSet FOLLOW_iriRef_in_iriRefOrFunction6646 = new BitSet(new long[]{0x0000000000000002L,0x0800000000000000L});
 25586  1
     public static final BitSet FOLLOW_argList_in_iriRefOrFunction6648 = new BitSet(new long[]{0x0000000000000002L});
 25587  1
     public static final BitSet FOLLOW_string_in_rdfLiteral6681 = new BitSet(new long[]{0x0000000000000002L,0x0000001000000000L,0x0000000000800000L});
 25588  1
     public static final BitSet FOLLOW_LANGTAG_in_rdfLiteral6684 = new BitSet(new long[]{0x0000000000000002L});
 25589  1
     public static final BitSet FOLLOW_REFERENCE_in_rdfLiteral6689 = new BitSet(new long[]{0x0000000000000000L,0x0000000008000000L,0x0000000000000600L});
 25590  1
     public static final BitSet FOLLOW_iriRef_in_rdfLiteral6691 = new BitSet(new long[]{0x0000000000000002L});
 25591  1
     public static final BitSet FOLLOW_numericLiteralUnsigned_in_numericLiteral6711 = new BitSet(new long[]{0x0000000000000002L});
 25592  1
     public static final BitSet FOLLOW_numericLiteralPositive_in_numericLiteral6719 = new BitSet(new long[]{0x0000000000000002L});
 25593  1
     public static final BitSet FOLLOW_numericLiteralNegative_in_numericLiteral6727 = new BitSet(new long[]{0x0000000000000002L});
 25594  1
     public static final BitSet FOLLOW_IRI_REF_in_iriRef6910 = new BitSet(new long[]{0x0000000000000002L});
 25595  1
     public static final BitSet FOLLOW_prefixedName_in_iriRef6918 = new BitSet(new long[]{0x0000000000000002L});
 25596  1
     public static final BitSet FOLLOW_BLANK_NODE_LABEL_in_blankNode6960 = new BitSet(new long[]{0x0000000000000002L});
 25597  1
     public static final BitSet FOLLOW_anon_in_blankNode6968 = new BitSet(new long[]{0x0000000000000002L});
 25598  1
     public static final BitSet FOLLOW_OPEN_SQUARE_BRACKET_in_anon6985 = new BitSet(new long[]{0x0000000040000000L});
 25599  1
     public static final BitSet FOLLOW_CLOSE_SQUARE_BRACKET_in_anon6987 = new BitSet(new long[]{0x0000000000000002L});
 25600  
 
 25601  
 }